+ * Applies the java plugin by default. + *
+ * Makes the os, ws and arch variables available for the project (via project.ext) for building against platform-dependent + * dependencies; for example
compile "eclipse:org.eclipse.swt.${project.ext.ws}.${project.ext.os}.${project.ext.arch}:+"
+ * + * To make the compilation work, the compileJava task depends on the establishment of the target platform. + *
+ * To construct the output jar just like Eclipse PDE the plugin loads the contents of the build.properties
+ * file and brings it in sync with the jar's content.
+ *
+ * The
+ * A feature project can specify its feature.xml with a very simple build script:
+ *
+ * Only thing this plugin does is basic validation if the feature.xml file and the build.properties file exists and
+ * It add everything to the plugin jar what is defined in the build.properties (just line in {@link EclipsePlugin#syncJarContentWithBuildProperties(Project)})
+ */
+class FeaturePlugin implements Plugin
+ * An example for a valid DSL:
+ *
+ * The main tasks contributed by this plugin are responsible to generate an Eclipse Update site. They are attached to
+ * the 'assemble' task. When executed, all project dependency jars are copied to the build folder, signed and published
+ * to the buildDir/repository folder.
+ */
+class UpdateSitePlugin implements Plugin
+ * This class is automatically instantiated by the Eclipse runtime and wired through the
+ * Bundle-Activator entry in the META-INF/MANIFEST.MF file. The registered
+ * instance can be obtained during runtime through the {@link CorePlugin#getInstance()} method.
+ *
+ * Moreover, this is the entry point for accessing associated services:
+ *
+ * The {@link #start(BundleContext)} and {@link #stop(BundleContext)} methods' responsibility is to
+ * assign and free the managed services along the plugin runtime lifecycle.
+ */
+@SuppressWarnings({ "unchecked", "rawtypes" })
+public final class CorePlugin extends Plugin {
+
+ public static final String PLUGIN_ID = "com.gradleware.tooling.eclipse.core";
+
+ private static CorePlugin plugin;
+
+ // do not use generics-aware signature since this causes compilation troubles (JDK, Spock)
+ // search the web for -target jsr14 to find out more about this obscurity
+ private ServiceRegistration loggerService;
+ private ServiceRegistration publishedGradleVersionsService;
+ private ServiceRegistration modelRepositoryProviderService;
+ private ServiceRegistration workspaceOperationsService;
+ private ServiceRegistration projectConfigurationManagerService;
+ private ServiceRegistration processStreamsProviderService;
+ private ServiceRegistration gradleLaunchConfigurationService;
+ private ServiceRegistration workbenchOperationsService;
+
+ // service tracker for each service to allow to register other service implementations of the
+ // same type but with higher prioritization, useful for testing
+ private ServiceTracker loggerServiceTracker;
+ private ServiceTracker publishedGradleVersionsServiceTracker;
+ private ServiceTracker modelRepositoryProviderServiceTracker;
+ private ServiceTracker workspaceOperationsServiceTracker;
+ private ServiceTracker projectConfigurationManagerServiceTracker;
+ private ServiceTracker processStreamsProviderServiceTracker;
+ private ServiceTracker gradleLaunchConfigurationServiceTracker;
+ private ServiceTracker workbenchOperationsServiceTracker;
+
+ @Override
+ public void start(BundleContext bundleContext) throws Exception {
+ super.start(bundleContext);
+ registerServices(bundleContext);
+ plugin = this;
+ }
+
+ @Override
+ public void stop(BundleContext context) throws Exception {
+ plugin = null;
+ unregisterServices();
+ super.stop(context);
+ }
+
+ private void registerServices(BundleContext context) {
+ // store services with low ranking such that they can be overridden
+ // during testing or the like
+ Dictionary
+ * By using this interface, we can log like this:
+ *
+ *
+ */
+public interface Logger {
+
+ /**
+ * Logs an entry with {@link org.eclipse.core.runtime.IStatus#INFO} severity in Eclipse's log.
+ *
+ * @param message the information to log
+ */
+ void info(String message);
+
+ /**
+ * Logs an entry with {@link org.eclipse.core.runtime.IStatus#WARNING} severity in Eclipse's log.
+ *
+ * @param message the warning to log
+ */
+ void warn(String message);
+
+ /**
+ * Logs an entry with {@link org.eclipse.core.runtime.IStatus#ERROR} severity in Eclipse's log.
+ *
+ * @param message the warning to log
+ */
+ void error(String message);
+
+ /**
+ * Logs an entry with {@link org.eclipse.core.runtime.IStatus#ERROR} severity in Eclipse's log.
+ *
+ * @param message the error to log
+ * @param t the underlying cause
+ */
+ void error(String message, Throwable t);
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/configuration/ProjectConfiguration.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/configuration/ProjectConfiguration.java
new file mode 100644
index 000000000..b1969ae21
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/configuration/ProjectConfiguration.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.configuration;
+
+import java.io.File;
+
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
+import com.gradleware.tooling.toolingmodel.OmniEclipseProject;
+import com.gradleware.tooling.toolingmodel.Path;
+import com.gradleware.tooling.toolingmodel.repository.FixedRequestAttributes;
+
+/**
+ * Describes the Gradle-specific configuration of an Eclipse project.
+ */
+public final class ProjectConfiguration {
+
+ private final FixedRequestAttributes requestAttributes;
+ private final Path projectPath;
+ private final File projectDir;
+
+ private ProjectConfiguration(FixedRequestAttributes requestAttributes, Path projectPath, File projectDir) {
+ this.requestAttributes = Preconditions.checkNotNull(requestAttributes);
+ this.projectPath = Preconditions.checkNotNull(projectPath);
+ this.projectDir = Preconditions.checkNotNull(projectDir);
+ }
+
+ /**
+ * Returns the request attributes that are used to connect to the Gradle project.
+ *
+ * @return the request attributes used to connect to the Gradle project, never null
+ */
+ public FixedRequestAttributes getRequestAttributes() {
+ return this.requestAttributes;
+ }
+
+ /**
+ * Returns the path of the Gradle project.
+ *
+ * @return the path of the Gradle project, never null
+ */
+ public Path getProjectPath() {
+ return this.projectPath;
+ }
+
+ /**
+ * Returns the location of the Gradle project.
+ *
+ * @return the location of the Gradle project, never null
+ */
+ public File getProjectDir() {
+ return this.projectDir;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (this == other) {
+ return true;
+ }
+ if (other == null || getClass() != other.getClass()) {
+ return false;
+ }
+
+ ProjectConfiguration that = (ProjectConfiguration) other;
+ return Objects.equal(this.requestAttributes, that.requestAttributes) && Objects.equal(this.projectDir, that.projectDir)
+ && Objects.equal(this.projectPath, that.projectPath);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.requestAttributes, this.projectDir, this.projectPath);
+ }
+
+ /**
+ * Creates a new instance.
+ *
+ * @param requestAttributes the connection aspects of the configuration
+ * @param project the project aspects of the configuration
+ * @return the new instance
+ */
+ public static ProjectConfiguration from(FixedRequestAttributes requestAttributes, OmniEclipseProject project) {
+ return from(requestAttributes, project.getPath(), project.getProjectDirectory());
+ }
+
+ /**
+ * Creates a new instance.
+ *
+ * @param requestAttributes the connection aspects of the configuration
+ * @param projectPath the path of the Gradle project
+ * @param projectDir the location of the Gradle project
+ * @return the new instance
+ */
+ public static ProjectConfiguration from(FixedRequestAttributes requestAttributes, Path projectPath, File projectDir) {
+ return new ProjectConfiguration(requestAttributes, projectPath, projectDir);
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/configuration/ProjectConfigurationManager.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/configuration/ProjectConfigurationManager.java
new file mode 100644
index 000000000..8ba258dc4
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/configuration/ProjectConfigurationManager.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.configuration;
+
+import org.eclipse.core.resources.IProject;
+
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * Manages the persisted configuration of Gradle projects in the Eclipse workspace.
+ */
+public interface ProjectConfigurationManager {
+
+ /**
+ * Returns the unique set of {@link ProjectConfiguration} roots found in the workspace.
+ *
+ * @return the unique set of {@code ProjectConfiguration} roots
+ */
+ ImmutableSet
+ * Each process description has a name and optionally an {@link ILaunch} instance and a {@link Job}
+ * instance which are performing the actual execution.
+ */
+public final class ProcessDescription {
+
+ private final String name;
+ private final Optional
+ * This implementation is useful in non-UI test scenarios.
+ */
+public final class StdProcessStreamsProvider implements ProcessStreamsProvider {
+
+ private final ProcessStreams stdStreams = new ProcessStreams() {
+
+ @Override
+ public InputStream getInput() {
+ return System.in;
+ }
+
+ @Override
+ public OutputStream getOutput() {
+ return System.out;
+ }
+
+ @Override
+ public OutputStream getError() {
+ return System.err;
+ }
+
+ @Override
+ public void close() {
+ // do nothing since we never want to close the std streams
+ }
+
+ };
+
+ @Override
+ public ProcessStreams getBackgroundJobProcessStreams() {
+ return this.stdStreams;
+ }
+
+ @Override
+ public ProcessStreams createProcessStreams(ProcessDescription processDescription) {
+ return this.stdStreams;
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/gradle/GradleConnectionValidators.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/gradle/GradleConnectionValidators.java
new file mode 100644
index 000000000..4a6fe74a4
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/gradle/GradleConnectionValidators.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.gradle;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Strings;
+import com.gradleware.tooling.eclipse.core.i18n.CoreMessages;
+import com.gradleware.tooling.toolingutils.binding.Validator;
+
+import java.io.File;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+/**
+ * Factory class for {@link Validator} instances that validate Gradle connections attributes.
+ */
+public final class GradleConnectionValidators {
+
+ private GradleConnectionValidators() {
+ }
+
+ public static Validator
+ * The delegate invokes the {@link RunGradleConfigurationDelegateJob} job to do the actual execution
+ * and waits until it finishes. It also propagates the cancellation to that job.
+ */
+public final class GradleRunConfigurationDelegate extends LaunchConfigurationDelegate {
+
+ // configuration type id declared in the plugin.xml
+ public static final String ID = "com.gradleware.tooling.eclipse.core.launch.runconfiguration";
+
+ @Override
+ public void launch(ILaunchConfiguration configuration, String mode, ILaunch launch, IProgressMonitor monitor) {
+ monitor.beginTask("Launch Gradle tasks", IProgressMonitor.UNKNOWN);
+ try {
+ // schedule the task
+ final CountDownLatch latch = new CountDownLatch(1);
+ RunGradleConfigurationDelegateJob job = new RunGradleConfigurationDelegateJob(launch, configuration);
+ job.addJobChangeListener(new JobChangeAdapter() {
+
+ @Override
+ public void done(IJobChangeEvent event) {
+ latch.countDown();
+ }
+ });
+ job.schedule();
+
+ // block until the task execution job has finished successfully or failed,
+ // periodically check if this launch has been cancelled, and if so, cancel
+ // the task execution job
+ try {
+ boolean cancelRequested = false;
+ while (!latch.await(500, TimeUnit.MILLISECONDS)) {
+ // regularly check if the job was cancelled
+ // until the job is either finished or failed
+ if (monitor.isCanceled() && !cancelRequested) {
+ // cancel the job only once
+ job.cancel();
+ cancelRequested = true;
+ }
+ }
+ } catch (InterruptedException e) {
+ CorePlugin.logger().error("Failed to launch Gradle tasks.", e);
+ }
+ } finally {
+ monitor.done();
+
+ // explicitly remove the launch since the code in DebugPlugin never removes the launch
+ // (we depend on the removal event being sent in the 'close console actions' since no
+ // other events of interest to us get ever fired)
+ DebugPlugin.getDefault().getLaunchManager().removeLaunch(launch);
+ }
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/launch/RunGradleConfigurationDelegateJob.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/launch/RunGradleConfigurationDelegateJob.java
new file mode 100644
index 000000000..41deb712e
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/launch/RunGradleConfigurationDelegateJob.java
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.launch;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.text.DateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.debug.core.ILaunch;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.gradle.tooling.BuildCancelledException;
+import org.gradle.tooling.BuildException;
+import org.gradle.tooling.TestProgressEvent;
+import org.gradle.tooling.TestProgressListener;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Predicate;
+import com.google.common.base.Strings;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableList;
+import com.gradleware.tooling.eclipse.core.CorePlugin;
+import com.gradleware.tooling.eclipse.core.GradlePluginsRuntimeException;
+import com.gradleware.tooling.eclipse.core.console.ProcessDescription;
+import com.gradleware.tooling.eclipse.core.console.ProcessStreams;
+import com.gradleware.tooling.eclipse.core.gradle.GradleDistributionFormatter;
+import com.gradleware.tooling.eclipse.core.i18n.CoreMessages;
+import com.gradleware.tooling.eclipse.core.testprogress.GradleTestRunSession;
+import com.gradleware.tooling.eclipse.core.testprogress.GradleTestRunSessionFactory;
+import com.gradleware.tooling.eclipse.core.util.collections.CollectionsUtils;
+import com.gradleware.tooling.eclipse.core.util.file.FileUtils;
+import com.gradleware.tooling.eclipse.core.util.progress.DelegatingProgressListener;
+import com.gradleware.tooling.eclipse.core.util.progress.ToolingApiJob;
+import com.gradleware.tooling.toolingclient.BuildLaunchRequest;
+import com.gradleware.tooling.toolingclient.GradleDistribution;
+import com.gradleware.tooling.toolingclient.LaunchableConfig;
+import com.gradleware.tooling.toolingclient.ToolingClient;
+
+/**
+ * Runs the given {@link ILaunch} instance.
+ */
+public final class RunGradleConfigurationDelegateJob extends ToolingApiJob {
+
+ // todo (etst) close streams when done
+
+ private final ILaunch launch;
+ private final ILaunchConfiguration launchConfiguration;
+
+ public RunGradleConfigurationDelegateJob(ILaunch launch, ILaunchConfiguration launchConfiguration) {
+ super("Launching Gradle tasks");
+
+ this.launch = Preconditions.checkNotNull(launch);
+ this.launchConfiguration = Preconditions.checkNotNull(launchConfiguration);
+ }
+
+ @Override
+ protected IStatus run(IProgressMonitor monitor) {
+ try {
+ runLaunchConfiguration(monitor);
+ return Status.OK_STATUS;
+ } catch (BuildCancelledException e) {
+ // if the job was cancelled by the user, do not show an error dialog
+ CorePlugin.logger().info(e.getMessage());
+ return Status.CANCEL_STATUS;
+ } catch (BuildException e) {
+ // return only a warning if there was a problem while running the Gradle build since the
+ // error is also visible in the Gradle console
+ return new Status(IStatus.WARNING, CorePlugin.PLUGIN_ID, "Gradle build failure during task execution.", e);
+ } catch (Exception e) {
+ return new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, "Launching the Gradle tasks failed.", e);
+ } finally {
+ monitor.done();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public void runLaunchConfiguration(IProgressMonitor monitor) {
+ // derive all build launch settings from the launch configuration
+ GradleRunConfigurationAttributes configurationAttributes = GradleRunConfigurationAttributes.from(this.launchConfiguration);
+ List
+ * While there is no target progress monitor set, the most recent progress message is preserved and
+ * automatically assigned once a monitor is set.
+ *
+ * @see IProgressMonitor
+ */
+public final class DelegatingProgressListener implements ProgressListener {
+
+ public final Object LOCK = new Object();
+
+ private IProgressMonitor monitor;
+ private String lastMessage;
+
+ /**
+ * Creates a new progress listener without an initial target Eclipse monitor.
+ */
+ public DelegatingProgressListener() {
+ this.monitor = null;
+ }
+
+ /**
+ * Creates a new progress listener with the given Eclipse target monitor.
+ *
+ * @param monitor the Eclipse target monitor to delegate to
+ */
+ public DelegatingProgressListener(IProgressMonitor monitor) {
+ this.monitor = monitor;
+ }
+
+ /**
+ * Sets the given Eclipse target monitor.
+ *
+ * @param monitor the Eclipse target monitor to delegate to
+ */
+ public void setMonitor(IProgressMonitor monitor) {
+ synchronized (this.LOCK) {
+ this.monitor = monitor;
+ if (this.monitor != null) {
+ this.monitor.subTask(this.lastMessage);
+ }
+ }
+ }
+
+ /**
+ * Delegates the event to the current Eclipse target monitor.
+ *
+ * @param event the event to delegate
+ */
+ @Override
+ public void statusChanged(ProgressEvent event) {
+ synchronized (this.LOCK) {
+ if (this.monitor != null) {
+ // if the monitor is present, then create a sub task for each progress event
+ this.monitor.subTask(event.getDescription());
+ } else {
+ // if a monitor is not present, preserve the last event
+ this.lastMessage = event.getDescription();
+ }
+ }
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/progress/ToolingApiJob.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/progress/ToolingApiJob.java
new file mode 100644
index 000000000..9ef6a2807
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/progress/ToolingApiJob.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.util.progress;
+
+import org.eclipse.core.runtime.jobs.Job;
+import org.gradle.tooling.CancellationToken;
+import org.gradle.tooling.CancellationTokenSource;
+import org.gradle.tooling.GradleConnector;
+
+/**
+ * Base class for cancellable jobs that invoke the Gradle Tooling API.
+ */
+public abstract class ToolingApiJob extends Job {
+
+ private final CancellationTokenSource tokenSource;
+
+ /**
+ * Creates a new job with the specified name. The job name is a human-readable value that is
+ * displayed to users. The name does not need to be unique, but it must not be {@code null}. A
+ * token for Gradle build cancellation is created.
+ *
+ * @param name the name of the job
+ */
+ protected ToolingApiJob(String name) {
+ super(name);
+ this.tokenSource = GradleConnector.newCancellationTokenSource();
+ }
+
+ protected CancellationToken getToken() {
+ return this.tokenSource.token();
+ }
+
+ @Override
+ protected void canceling() {
+ this.tokenSource.cancel();
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/progress/ToolingApiWorkspaceJob.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/progress/ToolingApiWorkspaceJob.java
new file mode 100644
index 000000000..226a5857d
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/progress/ToolingApiWorkspaceJob.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.util.progress;
+
+import org.eclipse.core.resources.WorkspaceJob;
+import org.gradle.tooling.CancellationToken;
+import org.gradle.tooling.CancellationTokenSource;
+import org.gradle.tooling.GradleConnector;
+
+/**
+ * Base class for cancellable workspace jobs that invoke the Gradle Tooling API.
+ */
+public abstract class ToolingApiWorkspaceJob extends WorkspaceJob {
+
+ private final CancellationTokenSource tokenSource;
+
+ /**
+ * Creates a new job with the specified name. The job name is a human-readable value that is
+ * displayed to users. The name does not need to be unique, but it must not be {@code null}. A
+ * token for Gradle build cancellation is created.
+ *
+ * @param name the name of the job
+ */
+ protected ToolingApiWorkspaceJob(String name) {
+ super(name);
+ this.tokenSource = GradleConnector.newCancellationTokenSource();
+ }
+
+ protected CancellationToken getToken() {
+ return this.tokenSource.token();
+ }
+
+ @Override
+ protected void canceling() {
+ this.tokenSource.cancel();
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/progress/UniqueJobRule.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/progress/UniqueJobRule.java
new file mode 100644
index 000000000..37ab9273b
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/progress/UniqueJobRule.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.util.progress;
+
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
+
+/**
+ * Simple {@link ISchedulingRule} implementation forcing only one job instance to run at once among
+ * all jobs with the associated rule instance applied.
+ */
+public final class UniqueJobRule implements ISchedulingRule {
+
+ private UniqueJobRule() {
+ }
+
+ @Override
+ public boolean contains(ISchedulingRule rule) {
+ return rule == this;
+ }
+
+ @Override
+ public boolean isConflicting(ISchedulingRule rule) {
+ return rule == this;
+ }
+
+ /**
+ * Creates a new instance.
+ *
+ * @return the new instance
+ */
+ public static ISchedulingRule newInstance() {
+ return new UniqueJobRule();
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/variable/ExpressionUtils.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/variable/ExpressionUtils.java
new file mode 100644
index 000000000..e58f1d4eb
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/util/variable/ExpressionUtils.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.util.variable;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.variables.IStringVariableManager;
+import org.eclipse.core.variables.VariablesPlugin;
+
+/**
+ * Contains helper methods related to variable expressions.
+ */
+public final class ExpressionUtils {
+
+ private static final String WORKSPACE_LOC_VARIABLE = "workspace_loc";
+
+ private ExpressionUtils() {
+ }
+
+ /**
+ * Encodes the workspace location of the given Eclipse project as a variable expression.
+ *
+ * @param project the project name to encode, must not be null
+ * @return the project reference as a variable expression, never null
+ */
+ public static String encodeWorkspaceLocation(IProject project) {
+ return getStringVariableManager().generateVariableExpression(WORKSPACE_LOC_VARIABLE, project.getFullPath().toString()); //$NON-NLS-1$
+ }
+
+ /**
+ * Decodes the given expression.
+ *
+ * @param expression the expression to decode, can be null
+ * @return the resolved expression, can be null
+ */
+ public static String decode(String expression) throws CoreException {
+ return expression != null ? getStringVariableManager().performStringSubstitution(expression) : null;
+ }
+
+ private static IStringVariableManager getStringVariableManager() {
+ return VariablesPlugin.getDefault().getStringVariableManager();
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workbench/WorkbenchOperations.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workbench/WorkbenchOperations.java
new file mode 100644
index 000000000..d85904171
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workbench/WorkbenchOperations.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.workbench;
+
+/**
+ * Provides operations related to the Eclipse workbench.
+ */
+public interface WorkbenchOperations {
+
+ /**
+ * Attempts to activate the Eclipse Test Runner View.
+ */
+ void activateTestRunnerView();
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workbench/internal/EmptyWorkbenchOperations.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workbench/internal/EmptyWorkbenchOperations.java
new file mode 100644
index 000000000..9d7783d21
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workbench/internal/EmptyWorkbenchOperations.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.workbench.internal;
+
+import com.gradleware.tooling.eclipse.core.workbench.WorkbenchOperations;
+
+/**
+ * Empty implementation of the {@link WorkbenchOperations} interface since the core plugin does
+ * not know about the workbench which is a part of the UI.
+ */
+public final class EmptyWorkbenchOperations implements WorkbenchOperations {
+
+ @Override
+ public void activateTestRunnerView() {
+ // do nothing
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workspace/ClasspathDefinition.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workspace/ClasspathDefinition.java
new file mode 100644
index 000000000..df3cab305
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workspace/ClasspathDefinition.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.workspace;
+
+import java.util.List;
+
+import org.eclipse.core.runtime.IPath;
+
+import com.google.common.collect.ImmutableList;
+import com.gradleware.tooling.toolingmodel.util.Pair;
+
+/**
+ * Value holder for defining the sources and classpath of a Java project.
+ */
+public final class ClasspathDefinition {
+
+ /**
+ * Id and string representation of the path where all Gradle projects store their external
+ * dependencies. This path is added during the project import and the
+ * {@code org.eclipse.jdt.core.classpathContainerInitializer} extension populates it with the
+ * actual external (source and binary) jars.
+ */
+ public static final String GRADLE_CLASSPATH_CONTAINER_ID = "com.gradleware.tooling.eclipse.core.gradleclasspathcontainer";
+
+ private final ImmutableList
+ * Useful to avoid having out-of-sync warnings showing up in the IDE.
+ *
+ * @param project the project to be refreshed
+ * @param monitor the monitor to report progress on
+ */
+ void refresh(IProject project, IProgressMonitor monitor);
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workspace/internal/DefaultWorkspaceOperations.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workspace/internal/DefaultWorkspaceOperations.java
new file mode 100644
index 000000000..d2029174e
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/workspace/internal/DefaultWorkspaceOperations.java
@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core.workspace.internal;
+
+import java.io.File;
+import java.util.List;
+
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.resources.IWorkspace;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.core.runtime.SubProgressMonitor;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.JavaModelException;
+
+import com.google.common.base.Function;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Predicate;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
+import com.gradleware.tooling.eclipse.core.CorePlugin;
+import com.gradleware.tooling.eclipse.core.GradlePluginsRuntimeException;
+import com.gradleware.tooling.eclipse.core.workspace.ClasspathDefinition;
+import com.gradleware.tooling.eclipse.core.workspace.WorkspaceOperations;
+
+/**
+ * Default implementation of the {@link WorkspaceOperations} interface.
+ */
+public final class DefaultWorkspaceOperations implements WorkspaceOperations {
+
+ @Override
+ public ImmutableListbundled scope, and copies
+ * them (including transitives) into the lib folder and modifies the bundle manifest to export all packages from the libraries.
+ */
+class BundlePlugin implements Plugingradle tasks.
+ */
+ static String getGradleTaskGroupName() {
+ return "Eclipse Plugin Build"
+ }
+
+ /**
+ * Eclipse runtime abbreviation of the operating system.
+ * http://help.eclipse.org/indigo/topic/org.eclipse.platform.doc.isv/reference/misc/runtime-options.html
+ *
+ * @return The operating system: 'linux', 'win32' or 'macosx'
+ */
+ static String getOs() {
+ OperatingSystem os = OperatingSystem.current()
+ os.isLinux() ? 'linux' : os.isWindows() ? 'win32' : os.isMacOsX() ? 'macosx': null
+ }
+
+ /**
+ * Eclipse runtime abbreviation of the windowing system.
+ * http://help.eclipse.org/indigo/topic/org.eclipse.platform.doc.isv/reference/misc/runtime-options.html
+ *
+ * @return The windowing system: 'gtk', 'win32' or 'cocoa'
+ */
+ static String getWs() {
+ OperatingSystem os = OperatingSystem.current()
+ os.isLinux() ? 'gtk' : os.isWindows() ? 'win32' : os.isMacOsX() ? 'cocoa' : null
+ }
+
+ /**
+ * Eclipse runtime abbreviation of the architecture.
+ * http://help.eclipse.org/indigo/topic/org.eclipse.platform.doc.isv/reference/misc/runtime-options.html
+ *
+ * @return The architecture: x86, x86_64 or ppc
+ */
+ static String getArch() {
+ System.getProperty("os.arch").contains("64") ? "x86_64" : "x86"
+ }
+
+ /**
+ * @return The list of Eclipse versions supported by this Eclipse build. Possible values: '37', '42', '43' or '44',
+ */
+ static List
+ apply plugin: eclipsebuild.Feature
+
+ feature {
+ featureXml = file('feature.xml')
+ }
+
+ *
+ * apply plugin: eclipsebuild.UpdateSite
+ *
+ * updateSite {
+ * siteDescriptor = file("category.xml")
+ * }
+ *
+ * Where the category.xml file exists in the project.
+ *
+ *
+ * org.eclipse.core.resources.natures
+ * extension point in the plugin.xml.
+ */
+public final class GradleNature implements IProjectNature {
+
+ // the nature ID has to be in the following format: ${PLUGIN_ID}.${NATURE_ID}
+ // the nature id is defined in the external (xml) file specified in the plugin.xml
+ public static final String ID = CorePlugin.PLUGIN_ID + ".nature";
+
+ private IProject project;
+
+ @Override
+ public void configure() {
+ }
+
+ @Override
+ public void deconfigure() {
+ }
+
+ @Override
+ public IProject getProject() {
+ return this.project;
+ }
+
+ @Override
+ public void setProject(IProject project) {
+ this.project = project;
+ }
+
+ /**
+ * Determines if the specified project has the Gradle nature applied.
+ *
+ * @param project the project to verify
+ * @return {@code true} iff the specified project has the Gradle nature applied
+ */
+ public static boolean isPresentOn(IProject project) {
+ // abort if the project is closed since we cannot investigate closed projects
+ if (!project.isOpen()) {
+ String message = String.format("Cannot investigate Gradle nature on closed project %s.", project);
+ CorePlugin.logger().error(message);
+ throw new GradlePluginsRuntimeException(message);
+ }
+
+ // check if the Gradle nature is applied
+ try {
+ return project.hasNature(ID);
+ } catch (CoreException e) {
+ String message = String.format("Cannot check for Gradle nature on project %s.", project);
+ CorePlugin.logger().error(message, e);
+ throw new GradlePluginsRuntimeException(message, e);
+ }
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/GradlePluginsRuntimeException.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/GradlePluginsRuntimeException.java
new file mode 100644
index 000000000..1ce0fc0e7
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/GradlePluginsRuntimeException.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core;
+
+/**
+ * Base class for all custom unchecked exception types thrown by the Gradle integration plugins.
+ */
+public class GradlePluginsRuntimeException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * Creates a new instance.
+ *
+ * @param message the detail message
+ */
+ public GradlePluginsRuntimeException(String message) {
+ super(message);
+ }
+
+ /**
+ * Creates a new instance.
+ *
+ * @param message the detail message
+ * @param cause the cause
+ */
+ public GradlePluginsRuntimeException(String message, Exception cause) {
+ super(message, cause);
+ }
+
+ /**
+ * Creates a new instance.
+ *
+ * @param cause the cause
+ */
+ public GradlePluginsRuntimeException(Exception cause) {
+ super(cause);
+ }
+
+}
diff --git a/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/Logger.java b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/Logger.java
new file mode 100644
index 000000000..19d1ad6d8
--- /dev/null
+++ b/com.gradleware.tooling.eclipse.core/src/main/java/com/gradleware/tooling/eclipse/core/Logger.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2015 the original author or authors.
+ * 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:
+ * Etienne Studer & Donát Csikós (Gradle Inc.) - initial API and implementation and initial documentation
+ */
+
+package com.gradleware.tooling.eclipse.core;
+
+/**
+ * Simplifying abstraction over Eclipse's logging ({@link org.eclipse.core.runtime.ILog}) interface.
+ *
+ * try {
+ * ...
+ * } catch (Exception e) {
+ * CorePlugin.logger().error(e);
+ * }o
+ *
+ *
+ * Instead of doing this:
+ *
+ *
+ * try {
+ * ...
+ * } catch (Exception e) {
+ * CorePlugin.getInstance().getLog().log(new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, "Error occurred", e));
+ * }
+ *
+ *