Merge branch 'master' of https://github.com/spring-projects/sts4

vscode-extensions/commons/language-server-commons/pom.xml

@@ -31,6 +31,11 @@
 	</properties>
 
 	<dependencies>
+		<dependency>
+			<groupId>org.springframework.ide.vscode</groupId>
+			<artifactId>util-commons</artifactId>
+			<version>${project.version}</version>
+		</dependency>
 		<!-- Java implementation of VS Code language server protocol -->
 		<dependency>
 			<groupId>io.typefox.lsapi</groupId>
@@ -74,6 +79,4 @@
 			<version>${jackson-2-version}</version>
 		</dependency>
 	</dependencies>
-
-
 </project>

vscode-extensions/commons/language-server-commons/src/main/java/org/springframework/ide/vscode/commons/reconcile/IDocument.java

@@ -0,0 +1,7 @@
+package org.springframework.ide.vscode.commons.reconcile;
+
+public interface IDocument {
+
+	String get();
+
+}

vscode-extensions/commons/language-server-commons/src/main/java/org/springframework/ide/vscode/commons/reconcile/IProblemCollector.java

@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2014-2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.commons.reconcile;
+
+public interface IProblemCollector {
+
+	void beginCollecting();
+	void endCollecting();
+	void accept(ReconcileProblem problem);
+
+	/**
+	 * Problem collector that simply ignores/discards anything passed to it.
+	 */
+	IProblemCollector NULL = new IProblemCollector() {
+		public void beginCollecting() {
+		}
+		public void endCollecting() {
+		}
+		public void accept(ReconcileProblem problem) {
+		}
+	};
+}

vscode-extensions/commons/language-server-commons/src/main/java/org/springframework/ide/vscode/commons/reconcile/IReconcileEngine.java

@@ -0,0 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.commons.reconcile;
+
+public interface IReconcileEngine {
+	public void reconcile(IDocument doc, IProblemCollector problemCollector);
+}

vscode-extensions/commons/language-server-commons/src/main/java/org/springframework/ide/vscode/commons/reconcile/ProblemSeverity.java

@@ -0,0 +1,12 @@
+package org.springframework.ide.vscode.commons.reconcile;
+
+/**
+ * @author Kris De Volder
+ */
+public enum ProblemSeverity {
+
+	IGNORE,
+	WARNING,
+	ERROR;
+
+}

vscode-extensions/commons/language-server-commons/src/main/java/org/springframework/ide/vscode/commons/reconcile/ProblemType.java

@@ -0,0 +1,18 @@
+package org.springframework.ide.vscode.commons.reconcile;
+
+/**
+ * Besides the methods below, the only hard requirement for a 'problem type' is
+ * that it is a unique object that is not 'equals' to any other object.
+ * <p>
+ * It is probably nice if you implement a good toString however.
+ * <p>
+ * A good way to implement a discrete set of problemType objects is as an enum
+ * that implements this interace.
+ *
+ * @author Kris De Volder
+ */
+public interface ProblemType {
+	ProblemSeverity getDefaultSeverity();
+	String toString();
+	String getCode();
+}

vscode-extensions/commons/language-server-commons/src/main/java/org/springframework/ide/vscode/commons/reconcile/ReconcileProblem.java

@@ -0,0 +1,15 @@
+package org.springframework.ide.vscode.commons.reconcile;
+
+/**
+ * Minamal interface that objects representing a reconciler problem must
+ * implement.
+ *
+ * @author Kris De Volder
+ */
+public interface ReconcileProblem {
+	ProblemType getType();
+	String getMessage();
+	int getOffset();
+	int getLength();
+	String getCode();
+}

vscode-extensions/commons/language-server-commons/src/main/java/org/springframework/ide/vscode/commons/reconcile/ReconcileProblemImpl.java

@@ -0,0 +1,48 @@
+package org.springframework.ide.vscode.commons.reconcile;
+
+/**
+ * An implementation of {@link ReconcileProblem} that is just a simple data object.
+ *
+ * @author Kris De Volder
+ */
+public class ReconcileProblemImpl implements ReconcileProblem {
+
+	final private ProblemType type;
+	final private String msg;
+	final private int offset;
+	final private int len;
+
+	public ReconcileProblemImpl(ProblemType type, String msg, int offset, int len) {
+		super();
+		this.type = type;
+		this.msg = msg;
+		this.offset = offset;
+		this.len = len;
+	}
+
+	@Override
+	public ProblemType getType() {
+		return type;
+	}
+
+	@Override
+	public String getMessage() {
+		return msg;
+	}
+
+	@Override
+	public int getOffset() {
+		return offset;
+	}
+
+	@Override
+	public int getLength() {
+		return len;
+	}
+
+	@Override
+	public String getCode() {
+		return getType().getCode();
+	}
+
+}

vscode-extensions/commons/language-server-commons/src/main/java/org/springframework/ide/vscode/util/SimpleTextDocumentService.java

@@ -260,7 +260,7 @@ public class SimpleTextDocumentService implements TextDocumentService {
 	}
 
 	public void publishDiagnostics(TextDocument doc, List<DiagnosticImpl> diagnostics) {
-		if (diagnostics!=null && !diagnostics.isEmpty()) {
+		if (diagnostics!=null) {
 			PublishDiagnosticsParamsImpl params = new PublishDiagnosticsParamsImpl();
 			params.setUri(doc.getUri());
 			params.setDiagnostics(diagnostics);

vscode-extensions/commons/language-server-commons/src/main/java/org/springframework/ide/vscode/util/TextDocument.java

@@ -1,9 +1,22 @@
 package org.springframework.ide.vscode.util;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.springframework.ide.vscode.commons.reconcile.IDocument;
+
+import io.typefox.lsapi.Position;
+import io.typefox.lsapi.PositionImpl;
 import io.typefox.lsapi.Range;
+import io.typefox.lsapi.RangeImpl;
 import io.typefox.lsapi.TextDocumentContentChangeEvent;
 
-public class TextDocument {
+public class TextDocument implements IDocument {
+	
+	Pattern NEWLINE = Pattern.compile("\\r|\\n|\\r\\n|\\n\\r");
+	private int[] _lineStarts;
 	
 	private final String uri;
 	private String text = "";
@@ -16,23 +29,96 @@ public class TextDocument {
 		return uri;
 	}
 	
-	public String getText() {
+	public String get() {
+		return getText();
+	}
+	
+	public synchronized String getText() {
 		return text;
 	}
 	
-	public void setText(String text) {
+	public synchronized void setText(String text) {
 		this.text = text;
+		this._lineStarts = null;
 	}
 	public void apply(TextDocumentContentChangeEvent change) {
 		Range rng = change.getRange();
 		if (rng==null) {
 			//full sync mode
-			this.text = change.getText();
+			setText(change.getText());
 		} else {
 			//incremental sync mode
 			throw new IllegalStateException("Incremental sync not yet implemented");
 		}
 	}
 
+	/**
+	 * Convert a simple offset+length pair into a vscode range. This is a method on 
+	 * TextDocument because it requires splitting document into lines to determine
+	 * line numbers from offsets.
+	 */
+	public RangeImpl toRange(int offset, int length) {
+		int end = offset + length;
+		RangeImpl range = new RangeImpl();
+		range.setStart(toPosition(offset));
+		range.setEnd(toPosition(end));
+		return range;
+	}
+	
+	/**
+	 * Determine the line-number a given offset (i.e. what line is the offset inside of?)
+	 */
+	private int lineNumber(int offset) {
+		int[] lineStarts = lineStarts();
+		// TODO Should really use binary search here for speed
+		int lineNumber = 0;
+		for (int i = 0; i < lineStarts.length; i++) {
+			if (lineStarts[i]<=offset) {
+				lineNumber = i;
+			} else {
+				return lineNumber;
+			}
+		}
+		return lineNumber;
+	}
+
+
+	public PositionImpl toPosition(int offset) {
+		int line = lineNumber(offset);
+		int startOfLine = startOfLine(line);
+		int column = offset - startOfLine;
+		PositionImpl pos = new PositionImpl();
+		pos.setCharacter(column);
+		pos.setLine(line);
+		return pos;
+	}
+
+	private int startOfLine(int line) {
+		return lineStarts()[line];
+	}
+
+	private synchronized int[] lineStarts() {
+		if (_lineStarts==null) {
+			_lineStarts = parseLines();
+		}
+		return _lineStarts;
+	}
+
+	private int[] parseLines() {
+		List<Integer> lineStarts = new ArrayList<>();
+		lineStarts.add(0);
+		Matcher matcher = NEWLINE.matcher(getText());
+		int pos = 0;
+		while (matcher.find(pos)) {
+			lineStarts.add(pos = matcher.end());
+		}
+		int[] array = new int[lineStarts.size()];
+		for (int i = 0; i < array.length; i++) {
+			array[i] = lineStarts.get(i);
+		}
+		return array;
+	}
+
+
 
 }

vscode-extensions/commons/language-server-test-harness/.classpath

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

vscode-extensions/commons/language-server-test-harness/.project

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>language-server-test-harness</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>

vscode-extensions/commons/language-server-test-harness/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,5 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8

vscode-extensions/commons/language-server-test-harness/.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

vscode-extensions/commons/language-server-test-harness/pom.xml

@@ -0,0 +1,33 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>language-server-test-harness</artifactId>
+	<name>language-server-test-harness</name>
+	<description>Test harness for testing language server functionaltity implemented in Java</description>
+
+	<parent>
+		<groupId>org.springframework.ide.vscode</groupId>
+		<artifactId>commons-parent</artifactId>
+		<version>0.0.1-SNAPSHOT</version>
+		<relativePath>../pom.xml</relativePath>
+	</parent>
+	
+	<dependencies>
+		<dependency>
+			<groupId>org.springframework.ide.vscode</groupId>
+			<artifactId>language-server-commons</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>${junit-version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.assertj</groupId>
+			<artifactId>assertj-core</artifactId>
+			<version>${assertj-version}</version>
+		</dependency>
+	</dependencies>
+
+</project>

vscode-extensions/commons/language-server-test-harness/src/main/java/org/springframework/ide/vscode/testharness/Editor.java

@@ -128,4 +128,16 @@ public class Editor {
 		return Collections.emptyList();
 	}
 
+	public void assertCompletions(String... specs) {
+		throw new UnsupportedOperationException("Not implemented yet!");
+	}
+
+	public void assertIsHoverRegion(String string) {
+		throw new UnsupportedOperationException("Not implemented yet!");
+	}
+
+	public void assertHoverContains(String string, String string2) {
+		throw new UnsupportedOperationException("Not implemented yet!");
+	}
+
 }

vscode-extensions/commons/language-server-test-harness/src/main/java/org/springframework/ide/vscode/testharness/LanguageServerHarness.java

@@ -34,8 +34,7 @@ import io.typefox.lsapi.services.LanguageServer;
 
 public class LanguageServerHarness {
 
-	//Warning this 'harness' is not very good yet. It just implements bare minimum to
-	// be able to test the MyLanguageServer example. 
+	//Warning this 'harness' is incomplete. Growing it as needed.
 
 	private Random random = new Random();
 

vscode-extensions/commons/pom.xml

@@ -7,12 +7,22 @@
 	<artifactId>commons-parent</artifactId>
 	<packaging>pom</packaging>
 	<version>0.0.1-SNAPSHOT</version>
-	<name>Parent pom for headless services written in Java</name>
+	<name>commons-parent</name>
 
 	<modules>
 		<module>language-server-commons</module>
+		<module>language-server-test-harness</module>
+		<module>yaml-commons</module>
+		<module>util-commons</module>
 	</modules>
 
+	<properties>
+		<junit-version>4.11</junit-version>
+		<assertj-version>3.5.2</assertj-version>
+		<slf4j-version>1.7.21</slf4j-version>
+		<guava-version>19.0</guava-version>
+	</properties>
+
 	<build>
 		<pluginManagement>
 			<plugins>
@@ -29,16 +39,21 @@
 	</build>
 
 	<dependencies>
+		<dependency>
+			<groupId>org.slf4j</groupId>
+			<artifactId>slf4j-api</artifactId>
+			<version>${slf4j-version}</version>
+		</dependency>
 		<dependency>
 			<groupId>junit</groupId>
 			<artifactId>junit</artifactId>
-			<version>4.11</version>
+			<version>${junit-version}</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.assertj</groupId>
 			<artifactId>assertj-core</artifactId>
-			<version>3.5.2</version>
+			<version>${assertj-version}</version>
 			<scope>test</scope>
 		</dependency>
 	</dependencies>

vscode-extensions/commons/util-commons/.classpath

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

vscode-extensions/commons/util-commons/.project

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>util-commons</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>

vscode-extensions/commons/util-commons/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,5 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8

vscode-extensions/commons/util-commons/.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

vscode-extensions/commons/util-commons/pom.xml

@@ -0,0 +1,13 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>util-commons</artifactId>
+  <name>util-commons</name>
+  
+  	<parent>
+		<groupId>org.springframework.ide.vscode</groupId>
+		<artifactId>commons-parent</artifactId>
+		<version>0.0.1-SNAPSHOT</version>
+		<relativePath>../pom.xml</relativePath>
+	</parent>
+
+</project>

vscode-extensions/commons/util-commons/src/main/java/org/springframework/ide/vscode/util/Assert.java

@@ -7,5 +7,11 @@ public class Assert {
 			throw new IllegalStateException(msg);
 		}
 	}
+
+	public static void isLegal(boolean b) {
+		if (!b) {
+			throw new IllegalStateException();
+		}
+	}
 	
 }

vscode-extensions/commons/util-commons/src/main/java/org/springframework/ide/vscode/util/Collector.java

@@ -0,0 +1,29 @@
+package org.springframework.ide.vscode.util;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * {@link IRequestor} that simplies stores all items received into
+ * a List
+ *
+ * @author Kris De Volder
+ */
+public class Collector<T> implements IRequestor<T> {
+
+	@SuppressWarnings("unchecked")
+	private List<T> nodes = Collections.EMPTY_LIST;
+
+	@Override
+	public void accept(T node) {
+		if (nodes==Collections.EMPTY_LIST) {
+			nodes = new ArrayList<T>();
+		}
+		nodes.add(node);
+	}
+
+	public List<T> get() {
+		return nodes;
+	}
+}

vscode-extensions/commons/util-commons/src/main/java/org/springframework/ide/vscode/util/ExceptionUtil.java

@@ -0,0 +1,68 @@
+package org.springframework.ide.vscode.util;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.concurrent.CancellationException;
+
+/**
+ * Utility methods to convert exceptions into other types of exceptions, status
+ * objects etc.
+ *
+ * @author Kris De Volder
+ */
+public class ExceptionUtil {
+
+	public static Throwable getDeepestCause(Throwable e) {
+		Throwable cause = e;
+		Throwable parent = e.getCause();
+		while (parent != null && parent != e) {
+			cause = parent;
+			parent = cause.getCause();
+		}
+		return cause;
+	}
+
+	public static String getMessage(Throwable e) {
+		// The message of nested exception is usually more interesting than the
+		// one on top.
+		Throwable cause = getDeepestCause(e);
+		String msg = cause.getClass().getSimpleName() + ": " + cause.getMessage();
+		return msg;
+	}
+
+	public static IllegalStateException notImplemented(String string) {
+		return new IllegalStateException("Not implemented: " + string);
+	}
+
+	public static boolean isCancelation(Throwable e) {
+		return (
+//				e instanceof OperationCanceledException ||
+				e instanceof InterruptedException ||
+				e instanceof CancellationException
+//				(
+//						e instanceof CoreException &&
+//						((CoreException)e).getStatus().getSeverity()==IStatus.CANCEL
+//				)
+		);
+	}
+
+	public static RuntimeException unchecked(Exception e) {
+		return new RuntimeException(e);
+	}
+
+	public static String stacktrace() {
+		return stacktrace(new Exception("Stacktrace"));
+	}
+
+	public static String stacktrace(Exception exception) {
+		ByteArrayOutputStream dump = new ByteArrayOutputStream();
+		PrintStream out = new PrintStream(dump);
+		try {
+			exception.printStackTrace(out);
+		} finally {
+			out.close();
+		}
+		return dump.toString();
+	}
+
+}

vscode-extensions/commons/util-commons/src/main/java/org/springframework/ide/vscode/util/IRequestor.java

@@ -0,0 +1,5 @@
+package org.springframework.ide.vscode.util;
+
+public interface IRequestor<T> {
+	void accept(T node);
+}

vscode-extensions/commons/util-commons/src/main/java/org/springframework/ide/vscode/util/RememberLast.java

@@ -0,0 +1,24 @@
+package org.springframework.ide.vscode.util;
+
+/**
+ * Requestor that remembers only the last item received.
+ *
+ * @author Kris De Volder
+ */
+public class RememberLast<T> implements IRequestor<T> {
+
+	private T last = null;
+
+	@Override
+	public void accept(T node) {
+		this.last = node;
+	}
+
+	/**
+	 * @return the last received item, may return null if no items where received.
+	 */
+	public T get() {
+		return last;
+	}
+
+}

vscode-extensions/commons/util-commons/src/main/java/org/springframework/ide/vscode/util/StringUtil.java

@@ -0,0 +1,20 @@
+package org.springframework.ide.vscode.util;
+
+public class StringUtil {
+	public static boolean hasText(String name) {
+		return name!=null && !name.trim().equals("");
+	}
+
+	public static String collectionToDelimitedString(Iterable<String> strings, String delim) {
+		StringBuilder b = new StringBuilder();
+		boolean first = true;
+		for (String s : strings) {
+			if (!first) {
+				b.append(delim);
+			}
+			b.append(s);
+			first = false;
+		}
+		return b.toString();
+	}
+}

vscode-extensions/commons/yaml-commons/.classpath

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

vscode-extensions/commons/yaml-commons/.project

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>yaml-commons</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>

vscode-extensions/commons/yaml-commons/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,5 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8

vscode-extensions/commons/yaml-commons/.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

vscode-extensions/commons/yaml-commons/pom.xml

@@ -0,0 +1,49 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>yaml-commons</artifactId>
+	<name>yaml-commons</name>
+	<description>Shared utilities for working with yaml</description>
+
+	<parent>
+		<groupId>org.springframework.ide.vscode</groupId>
+		<artifactId>commons-parent</artifactId>
+		<version>0.0.1-SNAPSHOT</version>
+		<relativePath>../pom.xml</relativePath>
+	</parent>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.springframework.ide.vscode</groupId>
+			<artifactId>util-commons</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.ide.vscode</groupId>
+			<artifactId>language-server-commons</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.yaml</groupId>
+			<artifactId>snakeyaml</artifactId>
+			<version>1.17</version>
+		</dependency>
+		<dependency>
+			<groupId>org.yaml</groupId>
+			<artifactId>snakeyaml</artifactId>
+			<version>1.17</version>
+		</dependency>
+		<dependency>
+			<groupId>javax.inject</groupId>
+			<artifactId>javax.inject</artifactId>
+			<version>1</version>
+		</dependency>
+		<dependency>
+			<groupId>com.google.guava</groupId>
+			<artifactId>guava</artifactId>
+			<version>${guava-version}</version>
+		</dependency>
+	</dependencies>
+
+
+</project>

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/ast/NodeRef.java

@@ -0,0 +1,190 @@
+package org.springframework.ide.vscode.yaml.ast;
+
+import org.yaml.snakeyaml.nodes.MappingNode;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.NodeTuple;
+import org.yaml.snakeyaml.nodes.SequenceNode;
+
+/**
+ * A node reference represents a 'pointer' to a location where a Node is stored.
+ * The concept is useful because when looking for a 'path' inside an Yaml AST a
+ * NodeRef makes it explicit where the node is with respect to some 'container'.
+ * For example it allows distinguishing between a reference to Node which is
+ * obtained from map key versus a map value.
+ *
+ * @author Kris De Volder
+ */
+public abstract class NodeRef<Parent> {
+
+	public static enum Kind {
+		ROOT, SEQ, KEY, VAL
+	}
+
+	private Parent parent;
+
+	public NodeRef(Parent parent) {
+		this.parent = parent;
+	}
+
+	public Parent getParent() {
+		return parent;
+	}
+
+	public abstract Node get();
+	public abstract void put(Node value);
+
+	public abstract String toString();
+
+	public abstract Kind getKind();
+
+	/**
+	 * Represents a reference to a root node, contained directly
+	 * inside a {@link YamlFileAST}
+	 */
+	public static class RootRef extends NodeRef<YamlFileAST> {
+		private int index;
+
+		public RootRef(YamlFileAST file, int index) {
+			super(file);
+			this.index = index;
+		}
+		@Override
+		public Node get() {
+			return getParent().get(index);
+		}
+
+		@Override
+		public void put(Node value) {
+			getParent().put(index, value);
+		}
+
+		@Override
+		public String toString() {
+			return "ROOT["+index+"]";
+		}
+		@Override
+		public Kind getKind() {
+			return Kind.ROOT;
+		}
+		public int getIndex() {
+			return index;
+		}
+	}
+
+	public static class SeqRef extends NodeRef<SequenceNode> {
+		private int index;
+		public SeqRef(SequenceNode seq, int index) {
+			super(seq);
+			this.index = index;
+		}
+		@Override
+		public Node get() {
+			return getParent().getValue().get(index);
+		}
+		@Override
+		public void put(Node value) {
+			getParent().getValue().set(index, value);
+		}
+		@Override
+		public String toString() {
+			return "["+index+"]";
+		}
+		@Override
+		public Kind getKind() {
+			return Kind.SEQ;
+		}
+		public int getIndex() {
+			return index;
+		}
+	}
+
+	/**
+	 * Abstract,  represent reference to either a key or
+	 * value inside a map tuple. Concrete subclasses define whether
+	 * key or value is being accessed.
+	 */
+	public static abstract class TupleRef extends NodeRef<MappingNode> {
+		protected int index;
+		public TupleRef(MappingNode map, int index) {
+			super(map);
+			this.index = index;
+		}
+
+		public NodeTuple getTuple() {
+			return getParent().getValue().get(index);
+		}
+
+		public void putTuple(NodeTuple value) {
+			getParent().getValue().set(index, value);
+		}
+	}
+
+	/**
+	 * References a key of a map entry
+	 */
+	public static class TupleKeyRef extends TupleRef {
+		public TupleKeyRef(MappingNode parent, int index) {
+			super(parent, index);
+		}
+
+		@Override
+		public Node get() {
+			return getTuple().getKeyNode();
+		}
+
+		@Override
+		public void put(Node newKey) {
+			NodeTuple tuple = getTuple();
+			putTuple(new NodeTuple(newKey, tuple.getValueNode()));
+		}
+
+		@Override
+		public String toString() {
+			return "@key["+index+"]";
+		}
+
+		@Override
+		public Kind getKind() {
+			return Kind.KEY;
+		}
+	}
+
+	/**
+	 * References a value of a map entry
+	 */
+	public static class TupleValueRef extends TupleRef {
+		public TupleValueRef(MappingNode parent, int index) {
+			super(parent, index);
+		}
+
+		@Override
+		public Node get() {
+			return getTuple().getValueNode();
+		}
+
+		@Override
+		public void put(Node newValue) {
+			NodeTuple t = getTuple();
+			putTuple(new NodeTuple(t.getKeyNode(), newValue));
+		}
+
+		@Override
+		public String toString() {
+			String keyString = NodeUtil.asScalar(getTuple().getKeyNode());
+			if (keyString!=null) {
+				//more readable to use the key value than the index of the tuple
+				return "@val['"+keyString+"']";
+			}
+			return "@val["+index+"]";
+		}
+
+		@Override
+		public Kind getKind() {
+			return Kind.VAL;
+		}
+
+		public Node getKey() {
+			return getTuple().getKeyNode();
+		}
+	}
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/ast/NodeUtil.java

@@ -0,0 +1,50 @@
+package org.springframework.ide.vscode.yaml.ast;
+
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.NodeId;
+import org.yaml.snakeyaml.nodes.ScalarNode;
+
+/**
+ * @author Kris De Volder
+ */
+public class NodeUtil {
+
+	/**
+	 * Determines whether a node contains the given offset.
+	 * The range a node covers between its begin and end mark is treated
+	 * as a half open interval. The start offset is treated as included
+	 * in the range but the end offset is excluded.
+	 * <p>
+	 * This is to avoid ambiguity as node ranges tend to 'join'
+	 * together so that the end region of one node coincides with
+	 * the start region of the next node. By treating node ranges
+	 * as 'half open' intervals every offset is typically only
+	 * part of two different nodes if those nodes effectively
+	 * have overlapping ranges (i.e. only if one node contains
+	 * the other). Thus, an operation like finding the smallest
+	 * node that contains an offset is unambgious.
+	 */
+	public static boolean contains(Node node, int offset) {
+		return getStart(node)<=offset && offset<getEnd(node);
+	}
+
+	public static int getStart(Node node) {
+		return node.getStartMark().getIndex();
+	}
+
+	public static int getEnd(Node node) {
+		return node.getEndMark().getIndex();
+	}
+
+	/**
+	 * Retrieve String value of a scalar node.
+	 * @return String value or null if node is not a Scalar node.
+	 */
+	public static String asScalar(Node node) {
+		if (node.getNodeId()==NodeId.scalar) {
+			return ((ScalarNode)node).getValue();
+		}
+		return null;
+	}
+
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/ast/YamlASTProvider.java

@@ -0,0 +1,8 @@
+package org.springframework.ide.vscode.yaml.ast;
+
+import org.springframework.ide.vscode.commons.reconcile.IDocument;
+
+@FunctionalInterface
+public interface YamlASTProvider {
+	YamlFileAST getAST(IDocument doc) throws Exception;
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/ast/YamlFileAST.java

@@ -0,0 +1,145 @@
+package org.springframework.ide.vscode.yaml.ast;
+
+import static org.springframework.ide.vscode.yaml.ast.NodeUtil.contains;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.ide.vscode.util.Collector;
+import org.springframework.ide.vscode.util.IRequestor;
+import org.springframework.ide.vscode.util.RememberLast;
+import org.springframework.ide.vscode.yaml.ast.NodeRef.RootRef;
+import org.springframework.ide.vscode.yaml.ast.NodeRef.SeqRef;
+import org.springframework.ide.vscode.yaml.ast.NodeRef.TupleKeyRef;
+import org.springframework.ide.vscode.yaml.ast.NodeRef.TupleValueRef;
+import org.yaml.snakeyaml.nodes.MappingNode;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.SequenceNode;
+
+/**
+ * Represents a parsed yml file.
+ *
+ * @author Kris De Volder
+ */
+public class YamlFileAST {
+
+	private static final List<NodeRef<?>> NO_CHILDREN = Collections.emptyList();
+	private List<Node> nodes;
+
+	public YamlFileAST(Iterable<Node> iter) {
+		nodes = new ArrayList<Node>();
+		for (Node node : iter) {
+			nodes.add(node);
+		}
+	}
+
+	public List<NodeRef<?>> findPath(int offset) {
+		Collector<NodeRef<?>> path = new Collector<NodeRef<?>>();
+		findPath(offset, path);
+		return path.get();
+	}
+
+	/**
+	 * Find 'smallest' ast node that contains offset. The pathRequestor will
+	 * be called as the search progresses down the AST on all nodes on the
+	 * path to the smallest node. If no node in the tree contains the offset
+	 * the requestor will not be called at all.
+	 */
+	public void findPath(int offset, IRequestor<NodeRef<?>> pathRequestor) {
+		for (int i = 0; i < nodes.size(); i++) {
+			Node node = nodes.get(i);
+			if (contains(node, offset)) {
+				pathRequestor.accept(new RootRef(this, i) );
+				findPath(node, offset, pathRequestor);
+				return;
+			}
+		}
+	}
+
+	/**
+	 * Find smallest node that is a child of 'n' that contains 'offset'. Each visited
+	 * node containing the offset, from the down to the found node are
+	 * passed to the pathRequestor.
+	 */
+	private void findPath(Node n, int offset, IRequestor<NodeRef<?>> pathRequestor) {
+		//TODO: avoid lots of garbage production by not using 'getChildren'
+		// but inling getChildren (i.e a switch-case that visits
+		// the children without putting them into temporary collections.)
+		// By doing this it should be possible to avoid creaing lots of temporary
+		// array lists and NodeRef objects and only create NodeRef objects for
+		// the nodes we actually care about (i.e. the ones on the path).
+		List<NodeRef<?>> children = getChildren(n);
+		for (int i = 0; i < children.size(); i++) {
+			NodeRef<?> c = children.get(i);
+			if (contains(c.get(), offset)) {
+				pathRequestor.accept(c);
+				findPath(c.get(), offset, pathRequestor);
+				return;
+			}
+		}
+	}
+
+	public static List<NodeRef<?>> getChildren(Node n) {
+		switch (n.getNodeId()) {
+		case scalar:
+			return NO_CHILDREN;
+		case sequence:
+			return getChildren((SequenceNode)n);
+		case mapping:
+			return getChildren((MappingNode)n);
+		case anchor:
+			//TODO: is this right? maybe we should visit down into 'realnode'
+			// but do we then potentially visit the same node twice?
+			return NO_CHILDREN;
+		}
+		return null;
+	}
+
+	public List<Node> getNodes() {
+		return nodes;
+	}
+
+	private static List<NodeRef<?>> getChildren(SequenceNode seq) {
+		int nodes = seq.getValue().size();
+		ArrayList<NodeRef<?>> children = new ArrayList<NodeRef<?>>(nodes);
+		for (int i = 0; i < nodes; i++) {
+			children.add(new SeqRef(seq, i));
+		}
+		return children;
+	}
+
+	private static List<NodeRef<?>> getChildren(MappingNode map) {
+		int entries = map.getValue().size();
+		ArrayList<NodeRef<?>> children = new ArrayList<NodeRef<?>>(entries*2);
+		for (int i = 0; i < entries; i++) {
+			children.add(new TupleKeyRef(map, i));
+			children.add(new TupleValueRef(map, i));
+		}
+		return children;
+	}
+
+	public NodeRef<?> findNodeRef(int offset) {
+		RememberLast<NodeRef<?>> lastNode = new RememberLast<NodeRef<?>>();
+		findPath(offset, lastNode);
+		return lastNode.get();
+	}
+
+	public Node findNode(int offset) {
+		NodeRef<?> ref = findNodeRef(offset);
+		if (ref!=null) {
+			return ref.get();
+		}
+		return null;
+	}
+
+	public Node get(int index) {
+		return nodes.get(index);
+	}
+
+	public void put(int index, Node value) {
+		nodes.set(index, value);
+	}
+
+
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/reconcile/SchemaBasedYamlASTReconciler.java

@@ -0,0 +1,167 @@
+package org.springframework.ide.vscode.yaml.reconcile;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.ide.vscode.commons.reconcile.IProblemCollector;
+import org.springframework.ide.vscode.util.ExceptionUtil;
+import org.springframework.ide.vscode.util.StringUtil;
+import org.springframework.ide.vscode.yaml.ast.NodeUtil;
+import org.springframework.ide.vscode.yaml.ast.YamlFileAST;
+import org.springframework.ide.vscode.yaml.schema.YType;
+import org.springframework.ide.vscode.yaml.schema.YTypeUtil;
+import org.springframework.ide.vscode.yaml.schema.YTypedProperty;
+import org.springframework.ide.vscode.yaml.schema.YamlSchema;
+import org.springframework.ide.vscode.yaml.util.ValueParser;
+import org.yaml.snakeyaml.nodes.MappingNode;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.NodeTuple;
+import org.yaml.snakeyaml.nodes.ScalarNode;
+import org.yaml.snakeyaml.nodes.SequenceNode;
+
+public class SchemaBasedYamlASTReconciler implements YamlASTReconciler {
+
+	private final IProblemCollector problems;
+	private final YamlSchema schema;
+	private final YTypeUtil typeUtil;
+
+	public SchemaBasedYamlASTReconciler(IProblemCollector problems, YamlSchema schema) {
+		this.problems = problems;
+		this.schema = schema;
+		this.typeUtil = schema.getTypeUtil();
+	}
+
+	@Override
+	public void reconcile(YamlFileAST ast) {
+		List<Node> nodes = ast.getNodes();
+		if (nodes!=null && !nodes.isEmpty()) {
+			for (Node node : nodes) {
+				reconcile(node, schema.getTopLevelType());
+			}
+		}
+	}
+
+	private void reconcile(Node node, YType type) {
+		if (type!=null) {
+			switch (node.getNodeId()) {
+			case mapping:
+				MappingNode map = (MappingNode) node;
+				if (typeUtil.isMap(type)) {
+					for (NodeTuple entry : map.getValue()) {
+						reconcile(entry.getKeyNode(), typeUtil.getKeyType(type));
+						reconcile(entry.getValueNode(), typeUtil.getDomainType(type));
+					}
+				} else if (typeUtil.isBean(type)) {
+					Map<String, YTypedProperty> beanProperties = typeUtil.getPropertiesMap(type);
+					for (NodeTuple entry : map.getValue()) {
+						Node keyNode = entry.getKeyNode();
+						String key = NodeUtil.asScalar(keyNode);
+						if (key==null) {
+							expectScalar(node);
+						} else {
+							YTypedProperty prop = beanProperties.get(key);
+							if (prop==null) {
+								unknownBeanProperty(keyNode, type, key);
+							} else {
+								reconcile(entry.getValueNode(), prop.getType());
+							}
+						}
+					}
+				} else {
+					expectTypeButFoundMap(type, node);
+				}
+				break;
+			case sequence:
+				SequenceNode seq = (SequenceNode) node;
+				if (typeUtil.isSequencable(type)) {
+					for (Node el : seq.getValue()) {
+						reconcile(el, typeUtil.getDomainType(type));
+					}
+				} else {
+					expectTypeButFoundSequence(type, node);
+				}
+				break;
+			case scalar:
+				if (typeUtil.isAtomic(type)) {
+					ValueParser parser = typeUtil.getValueParser(type);
+					if (parser!=null) {
+						try {
+							parser.parse(NodeUtil.asScalar(node));
+						} catch (Exception e) {
+							String msg = ExceptionUtil.getMessage(e);
+							valueParseError(type, node, msg);
+						}
+					}
+				} else {
+					expectTypeButFoundScalar(type, node);
+				}
+				break;
+			default:
+				// other stuff we don't check
+			}
+		}
+	}
+
+	private void valueParseError(YType type, Node node, String parseErrorMsg) {
+		String msg= "Couldn't parse as '"+describe(type)+"'";
+		if (StringUtil.hasText(parseErrorMsg)) {
+			msg += " ("+parseErrorMsg+")";
+		}
+		problem(node, msg);
+	}
+
+	private void unknownBeanProperty(Node keyNode, YType type, String name) {
+		problem(keyNode, "Unknown property '"+name+"' for type '"+typeUtil.niceTypeName(type)+"'");
+	}
+
+	private void expectScalar(Node node) {
+		problem(node, "Expecting a 'Scalar' node but got "+describe(node));
+	}
+
+	private String describe(Node node) {
+		switch (node.getNodeId()) {
+		case scalar:
+			return "'"+((ScalarNode)node).getValue()+"'";
+		case mapping:
+			return "a 'Mapping' node";
+		case sequence:
+			return "a 'Sequence' node";
+		case anchor:
+			return "a 'Anchor' node";
+		default:
+			throw new IllegalStateException("Missing switch case");
+		}
+	}
+
+	private void expectTypeButFoundScalar(YType type, Node node) {
+		problem(node, "Expecting a '"+describe(type)+"' but found a 'Scalar'");
+	}
+
+	private void expectTypeButFoundSequence(YType type, Node node) {
+		problem(node, "Expecting a '"+describe(type)+"' but found a 'Sequence'");
+	}
+
+	private void expectTypeButFoundMap(YType type, Node node) {
+		problem(node, "Expecting a '"+describe(type)+"' but found a 'Map'");
+	}
+
+	private String describe(YType type) {
+		if (typeUtil.isAtomic(type)) {
+			return typeUtil.niceTypeName(type);
+		}
+		ArrayList<String> expectedNodeTypes = new ArrayList<>();
+		if (typeUtil.isBean(type) || typeUtil.isMap(type)) {
+			expectedNodeTypes.add("Map");
+		}
+		if (typeUtil.isSequencable(type)) {
+			expectedNodeTypes.add("Sequence");
+		}
+		return StringUtil.collectionToDelimitedString(expectedNodeTypes, " or ");
+	}
+
+	private void problem(Node node, String msg) {
+		problems.accept(YamlSchemaProblems.schemaProblem(msg, node));
+	}
+
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/reconcile/YamlASTReconciler.java

@@ -0,0 +1,7 @@
+package org.springframework.ide.vscode.yaml.reconcile;
+
+import org.springframework.ide.vscode.yaml.ast.YamlFileAST;
+
+public interface YamlASTReconciler {
+	void reconcile(YamlFileAST ast);
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/reconcile/YamlReconcileEngine.java

@@ -0,0 +1,54 @@
+package org.springframework.ide.vscode.yaml.reconcile;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ide.vscode.commons.reconcile.IDocument;
+import org.springframework.ide.vscode.commons.reconcile.IProblemCollector;
+import org.springframework.ide.vscode.commons.reconcile.IReconcileEngine;
+import org.springframework.ide.vscode.commons.reconcile.ReconcileProblem;
+import org.springframework.ide.vscode.yaml.ast.YamlASTProvider;
+import org.springframework.ide.vscode.yaml.ast.YamlFileAST;
+import org.yaml.snakeyaml.error.Mark;
+import org.yaml.snakeyaml.parser.ParserException;
+import org.yaml.snakeyaml.scanner.ScannerException;
+
+/**
+ * @author Kris De Volder
+ */
+public abstract class YamlReconcileEngine implements IReconcileEngine {
+	
+	final static Logger logger = LoggerFactory.getLogger(YamlReconcileEngine.class);
+
+	protected final YamlASTProvider parser;
+
+	public YamlReconcileEngine(YamlASTProvider parser) {
+		this.parser = parser;
+	}
+
+	@Override
+	public void reconcile(IDocument doc, IProblemCollector problemCollector) {
+		problemCollector.beginCollecting();
+		try {
+			YamlFileAST ast = parser.getAST(doc);
+			YamlASTReconciler reconciler = getASTReconciler(doc, problemCollector);
+			if (reconciler!=null) {
+				reconciler.reconcile(ast);
+			}
+		} catch (ParserException e) {
+			String msg = e.getProblem();
+			Mark mark = e.getProblemMark();
+			problemCollector.accept(syntaxError(msg, mark.getIndex(), 1));
+		} catch (ScannerException e) {
+			String msg = e.getProblem();
+			Mark mark = e.getProblemMark();
+			problemCollector.accept(syntaxError(msg, mark.getIndex(), 1));
+		} catch (Exception e) {
+			logger.error("unexpected error during reconcile", e);
+		} finally {
+			problemCollector.endCollecting();
+		}
+	}
+
+	protected abstract ReconcileProblem syntaxError(String msg, int offset, int length);
+	protected abstract YamlASTReconciler getASTReconciler(IDocument doc, IProblemCollector problemCollector);
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/reconcile/YamlSchemaBasedReconcileEngine.java

@@ -0,0 +1,29 @@
+package org.springframework.ide.vscode.yaml.reconcile;
+
+import org.springframework.ide.vscode.commons.reconcile.IDocument;
+import org.springframework.ide.vscode.commons.reconcile.IProblemCollector;
+import org.springframework.ide.vscode.commons.reconcile.ReconcileProblem;
+import org.springframework.ide.vscode.yaml.ast.YamlASTProvider;
+import org.springframework.ide.vscode.yaml.schema.YamlSchema;
+
+/**
+ * @author Kris De Volder
+ */
+public final class YamlSchemaBasedReconcileEngine extends YamlReconcileEngine {
+	private final YamlSchema schema;
+
+	public YamlSchemaBasedReconcileEngine(YamlASTProvider parser, YamlSchema schema) {
+		super(parser);
+		this.schema = schema;
+	}
+
+	@Override
+	protected ReconcileProblem syntaxError(String msg, int offset, int length) {
+		return YamlSchemaProblems.syntaxProblem(msg, offset, length);
+	}
+
+	@Override
+	protected YamlASTReconciler getASTReconciler(IDocument doc, IProblemCollector problems) {
+		return new SchemaBasedYamlASTReconciler(problems, schema);
+	}
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/reconcile/YamlSchemaProblems.java

@@ -0,0 +1,45 @@
+package org.springframework.ide.vscode.yaml.reconcile;
+
+import org.springframework.ide.vscode.commons.reconcile.ProblemSeverity;
+import org.springframework.ide.vscode.commons.reconcile.ProblemType;
+import org.springframework.ide.vscode.commons.reconcile.ReconcileProblem;
+import org.springframework.ide.vscode.commons.reconcile.ReconcileProblemImpl;
+import org.yaml.snakeyaml.nodes.Node;
+
+/**
+ * Methods for creating reconciler problems for Schema based reconciler implementation.
+ *
+ * @author Kris De Volder
+ */
+public class YamlSchemaProblems {
+
+	private static final ProblemType SCHEMA_PROBLEM = problemType("YamlSchemaProblem");
+	private static final ProblemType SYNTAX_PROBLEM = problemType("YamlSyntaxProblem");
+
+	private static ProblemType problemType(final String typeName) {
+		return new ProblemType() {
+			@Override
+			public String toString() {
+				return typeName;
+			}
+			@Override
+			public ProblemSeverity getDefaultSeverity() {
+				return ProblemSeverity.ERROR;
+			}
+			@Override
+			public String getCode() {
+				return typeName;
+			}
+		};
+	}
+
+	public static ReconcileProblem syntaxProblem(String msg, int offset, int len) {
+		return new ReconcileProblemImpl(SYNTAX_PROBLEM, msg, offset, len);
+	}
+
+	public static ReconcileProblem schemaProblem(String msg, Node node) {
+		int start = node.getStartMark().getIndex();
+		int end = node.getEndMark().getIndex();
+		return new ReconcileProblemImpl(SCHEMA_PROBLEM, msg, start, end-start);
+	}
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/schema/BasicYValueHint.java

@@ -0,0 +1,79 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.schema;
+
+public class BasicYValueHint implements YValueHint {
+
+	private final String value;
+	private String label;
+
+	public BasicYValueHint(String value, String label) {
+		this.value = value;
+		this.label = label;
+	}
+
+	public BasicYValueHint(String value) {
+		this.value = value;
+		this.label = value;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.springframework.ide.eclipse.cloudfoundry.manifest.editor.YValueHint#getValue()
+	 */
+	@Override
+	public String getValue() {
+		return value;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.springframework.ide.eclipse.cloudfoundry.manifest.editor.YValueHint#getLabel()
+	 */
+	@Override
+	public String getLabel() {
+		return label;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((label == null) ? 0 : label.hashCode());
+		result = prime * result + ((value == null) ? 0 : value.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		BasicYValueHint other = (BasicYValueHint) obj;
+		if (label == null) {
+			if (other.label != null)
+				return false;
+		} else if (!label.equals(other.label))
+			return false;
+		if (value == null) {
+			if (other.value != null)
+				return false;
+		} else if (!value.equals(other.value))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "BasicYValueHint [value=" + value + ", label=" + label + "]";
+	}
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/schema/YType.java

@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.schema;
+
+/**
+ * Marker interface for objects that carry 'type information'.
+ * <p>
+ * It may seem odd that this interface has no actual methods. This
+ * is because the methods for interpreting the types are defined
+ * by an accompanying {@link YTypeUtil}.
+ * <p>
+ * The main reason why it works this way is to allow for 'YType' objects
+ * themselves to be implemented as dumb data objects while making YTypeUtil
+ * implementations define how to interpret these objects using context
+ * information (e.g. types resolved from a project's classpath).
+ *
+ * @author Kris De Volder
+ */
+public interface YType {
+
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/schema/YTypeFactory.java

@@ -0,0 +1,364 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.schema;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.inject.Provider;
+
+import org.springframework.ide.vscode.yaml.util.Description;
+import org.springframework.ide.vscode.yaml.util.DescriptionProviders;
+import org.springframework.ide.vscode.yaml.util.EnumValueParser;
+import org.springframework.ide.vscode.yaml.util.ValueParser;
+
+/**
+ * Static utility method for creating YType objects representing either
+ * 'array-like', 'map-like' or 'object-like' types which can be used
+ * to build up a 'Yaml Schema'.
+ *
+ * @author Kris De Volder
+ */
+public class YTypeFactory {
+
+	public YType yseq(YType el) {
+		return new YSeqType(el);
+	}
+
+	public YType ymap(YType key, YType val) {
+		return new YMapType(key, val);
+	}
+
+	public YBeanType ybean(String name, YTypedProperty... properties) {
+		return new YBeanType(name, properties);
+	}
+
+	/**
+	 * YTypeUtil instances capable of 'interpreting' the YType objects created by this
+	 * YTypeFactory
+	 */
+	public final YTypeUtil TYPE_UTIL = new YTypeUtil() {
+
+		@Override
+		public boolean isSequencable(YType type) {
+			return ((AbstractType)type).isSequenceable();
+		}
+
+		@Override
+		public boolean isMap(YType type) {
+			return ((AbstractType)type).isMap();
+		}
+
+		@Override
+		public boolean isAtomic(YType type) {
+			return ((AbstractType)type).isAtomic();
+		}
+
+		@Override
+		public Map<String, YTypedProperty> getPropertiesMap(YType type) {
+			return ((AbstractType)type).getPropertiesMap();
+		}
+
+		@Override
+		public List<YTypedProperty> getProperties(YType type) {
+			return ((AbstractType)type).getProperties();
+		}
+
+		@Override
+		public YValueHint[] getHintValues(YType type) {
+			return ((AbstractType)type).getHintValues();
+		}
+
+		@Override
+		public YType getDomainType(YType type) {
+			return ((AbstractType)type).getDomainType();
+		}
+
+		@Override
+		public String niceTypeName(YType type) {
+			return type.toString();
+		}
+
+		@Override
+		public YType getKeyType(YType type) {
+			return ((AbstractType)type).getKeyType();
+		}
+
+		@Override
+		public boolean isBean(YType type) {
+			return ((AbstractType)type).isBean();
+		}
+
+		@Override
+		public ValueParser getValueParser(YType type) {
+			return ((AbstractType)type).getParser();
+		}
+	};
+
+	/////////////////////////////////////////////////////////////////////////////////////
+
+	/**
+	 * Provides default implementations for all YType methods.
+	 */
+	public static abstract class AbstractType implements YType {
+
+		private ValueParser parser;
+		private List<YTypedProperty> propertyList = new ArrayList<>();
+		private final List<YValueHint> hints = new ArrayList<>();
+		private Map<String, YTypedProperty> cachedPropertyMap;
+		private Provider<Collection<YValueHint>> hintProvider;
+
+		public boolean isSequenceable() {
+			return false;
+		}
+
+		public boolean isBean() {
+			return false;
+		}
+
+		public YType getKeyType() {
+			return null;
+		}
+
+		public YType getDomainType() {
+			return null;
+		}
+
+		public void addHintProvider(Provider<Collection<YValueHint>> hintProvider) {
+			this.hintProvider = hintProvider;
+		}
+
+		public YValueHint[] getHintValues() {
+			Collection<YValueHint> providerHints = hintProvider != null ? hintProvider.get() : null;
+
+			if (providerHints == null || providerHints.isEmpty()) {
+				return hints.toArray(new YValueHint[hints.size()]);
+			} else {
+				// Only merge if there are provider hints to merge
+				Set<YValueHint> mergedHints = new LinkedHashSet<>();
+
+				// Add type hints first
+				for (YValueHint val : hints) {
+					mergedHints.add(val);
+				}
+
+				// merge the provider hints
+				for (YValueHint val : providerHints) {
+					mergedHints.add(val);
+				}
+				return mergedHints.toArray(new YValueHint[mergedHints.size()]);
+			}
+		}
+
+		public final List<YTypedProperty> getProperties() {
+			return Collections.unmodifiableList(propertyList);
+		}
+
+		public final Map<String, YTypedProperty> getPropertiesMap() {
+			if (cachedPropertyMap==null) {
+				cachedPropertyMap = new LinkedHashMap<>();
+				for (YTypedProperty p : propertyList) {
+					cachedPropertyMap.put(p.getName(), p);
+				}
+			}
+			return Collections.unmodifiableMap(cachedPropertyMap);
+		}
+
+		public boolean isAtomic() {
+			return false;
+		}
+
+		public boolean isMap() {
+			return false;
+		}
+
+		public abstract String toString(); // force each sublcass to implement a (nice) toString method.
+
+		public void addProperty(YTypedProperty p) {
+			cachedPropertyMap = null;
+			propertyList.add(p);
+		}
+
+		public void addProperty(String name, YType type, Provider<Description> description) {
+			YTypedPropertyImpl prop;
+			addProperty(prop = new YTypedPropertyImpl(name, type));
+			prop.setDescriptionProvider(description);
+		}
+
+		public void addProperty(String name, YType type) {
+			addProperty(new YTypedPropertyImpl(name, type));
+		}
+		public void addHints(String... strings) {
+			if (strings != null) {
+				for (String value : strings) {
+					BasicYValueHint hint = new BasicYValueHint(value);
+					if (!hints.contains(hint)) {
+						hints.add(hint);
+					}
+				}
+			}
+		}
+		public void parseWith(ValueParser parser) {
+			this.parser = parser;
+		}
+		public ValueParser getParser() {
+			return parser;
+		}
+	}
+
+	public static class YMapType extends AbstractType {
+
+		private final YType key;
+		private final YType val;
+
+		private YMapType(YType key, YType val) {
+			this.key = key;
+			this.val = val;
+		}
+
+		@Override
+		public String toString() {
+			return "Map<"+key.toString()+", "+val.toString()+">";
+		}
+
+		@Override
+		public boolean isMap() {
+			return true;
+		}
+
+		@Override
+		public YType getKeyType() {
+			return key;
+		}
+
+		@Override
+		public YType getDomainType() {
+			return val;
+		}
+	}
+
+	public static class YSeqType extends AbstractType {
+
+		private YType el;
+
+		private YSeqType(YType el) {
+			this.el = el;
+		}
+
+		@Override
+		public String toString() {
+			return el.toString()+"[]";
+		}
+
+		@Override
+		public boolean isSequenceable() {
+			return true;
+		}
+
+		@Override
+		public YType getDomainType() {
+			return el;
+		}
+	}
+
+	public static class YBeanType extends AbstractType {
+		private final String name;
+
+		public YBeanType(String name, YTypedProperty[] properties) {
+			this.name = name;
+			for (YTypedProperty p : properties) {
+				addProperty(p);
+			}
+		}
+
+		@Override
+		public String toString() {
+			return name;
+		}
+
+		public boolean isBean() {
+			return true;
+		}
+	}
+
+	public static class YAtomicType extends AbstractType {
+		private final String name;
+		private YAtomicType(String name) {
+			this.name = name;
+		}
+		@Override
+		public String toString() {
+			return name;
+		}
+		@Override
+		public boolean isAtomic() {
+			return true;
+		}
+	}
+
+	public static class YTypedPropertyImpl implements YTypedProperty {
+
+		final private String name;
+		final private YType type;
+		private Provider<Description> descriptionProvider = DescriptionProviders.NO_DESCRIPTION;
+
+		private YTypedPropertyImpl(String name, YType type) {
+			this.name = name;
+			this.type = type;
+		}
+
+		@Override
+		public String getName() {
+			return this.name;
+		}
+
+		@Override
+		public YType getType() {
+			return this.type;
+		}
+
+		@Override
+		public String toString() {
+			return name + ":" + type;
+		}
+
+		@Override
+		public Description getDescription() {
+			return descriptionProvider.get();
+		}
+
+		public void setDescriptionProvider(Provider<Description> descriptionProvider) {
+			this.descriptionProvider = descriptionProvider;
+		}
+
+	}
+
+	public YAtomicType yatomic(String name) {
+		return new YAtomicType(name);
+	}
+
+	public YTypedPropertyImpl yprop(String name, YType type) {
+		return new YTypedPropertyImpl(name, type);
+	}
+
+	public YAtomicType yenum(String name, String... values) {
+		YAtomicType t = yatomic(name);
+		t.addHints(values);
+		t.parseWith(new EnumValueParser(name, values));
+		return t;
+	}
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/schema/YTypeUtil.java

@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.schema;
+
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.ide.vscode.yaml.util.ValueParser;
+
+/**
+ * An implementation of YTypeUtil provides implementations of various
+ * methods operating on YTypes and interpreting them in some context
+ * (e.g. the meaning of YType objects may depend on types resolved
+ * from the current project's classpath).
+ *
+ * @author Kris De Volder
+ */
+public interface YTypeUtil {
+	boolean isAtomic(YType type);
+	boolean isMap(YType type);
+	boolean isSequencable(YType type);
+	boolean isBean(YType type);
+	YType getDomainType(YType type);
+	YValueHint[] getHintValues(YType yType);
+	String niceTypeName(YType type);
+	YType getKeyType(YType type);
+	ValueParser getValueParser(YType type);
+
+	//TODO: only one of these two should be enough?
+	List<YTypedProperty> getProperties(YType type);
+	Map<String, YTypedProperty> getPropertiesMap(YType yType);
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/schema/YTypedProperty.java

@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.schema;
+
+import org.springframework.ide.vscode.yaml.util.Description;
+
+/**
+ * @author Kris De Volder
+ */
+public interface YTypedProperty {
+	String getName();
+	YType getType();
+	Description getDescription();
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/schema/YValueHint.java

@@ -0,0 +1,19 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.schema;
+
+public interface YValueHint {
+
+	String getValue();
+
+	String getLabel();
+
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/schema/YamlSchema.java

@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.schema;
+
+/**
+ * A 'schema' provides a toplevel type, which dictates the valid structure of a
+ * YamlDocument and a {@link YTypeUtil} which provides the means to 'interpret'
+ * the types.
+ *
+ * @author Kris De Volder
+ */
+public interface YamlSchema {
+
+	YType getTopLevelType();
+	YTypeUtil getTypeUtil();
+
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/util/Description.java

@@ -0,0 +1,31 @@
+package org.springframework.ide.vscode.yaml.util;
+
+public abstract class Description {
+	
+	public abstract void renderAsText(StringBuilder buf);
+	
+	public void renderAsHtml(StringBuilder buf) {
+		throw new UnsupportedOperationException("Rendering as html not supported");
+	}
+	
+	public static Description text(String text) {
+		return new Description() {
+			@Override
+			public void renderAsText(StringBuilder buf) {
+				buf.append(text);
+			}
+		};
+	}
+
+	public static Description italic(Description d) {
+		//Not really supported, we just ignore italic and display as is
+		return d;
+	}
+
+	public String toText() {
+		StringBuilder buf = new StringBuilder();
+		renderAsText(buf);
+		return buf.toString();
+	}
+
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/util/DescriptionProviders.java

@@ -0,0 +1,66 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.util;
+
+import java.io.InputStream;
+
+import javax.inject.Provider;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.springframework.ide.vscode.yaml.util.Description.*;
+
+/**
+ * Static methods and convenience constants for creating some 'description providers'.
+ *
+ * @author Kris De Volder
+ */
+public class DescriptionProviders {
+	
+	final static Logger logger = LoggerFactory.getLogger(DescriptionProviders.class);
+
+	public static final Provider<Description> NO_DESCRIPTION = () -> italic(text("no description"));
+
+	public static Provider<Description> snippet(final Description snippet) {
+		return new Provider<Description>() {
+			@Override
+			public String toString() {
+				return snippet.toString();
+			}
+			@Override
+			public Description get() {
+				return snippet;
+			}
+		};
+	}
+
+	public static Provider<Description> fromClasspath(final Class<?> klass, final String resourcePath) {
+		return new Provider<Description>() {
+			@Override
+			public String toString() {
+				return "DescriptionFromClassPth(class="+klass.getSimpleName()+", "+resourcePath+")";
+			}
+			@Override
+			public Description get() {
+				try {
+					InputStream stream = klass.getResourceAsStream(resourcePath);
+					if (stream!=null) {
+						return Description.text(IOUtil.toString(stream));
+					}
+				} catch (Exception e) {
+					logger.error("Error", e);;
+				}
+				return NO_DESCRIPTION.get();
+			}
+		};
+	}
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/util/EnumValueParser.java

@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2014-2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.util;
+
+import java.util.Collection;
+import java.util.Set;
+
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * Parser for checking a 'Enum' style values.
+ *
+ * @author Kris De Volder
+ */
+public class EnumValueParser implements ValueParser {
+
+	private String typeName;
+	private Set<String> values;
+
+	public EnumValueParser(String typeName, String... values) {
+		this(typeName, ImmutableSet.copyOf(values));
+	}
+
+	public EnumValueParser(String typeName, Collection<String> values) {
+		this.typeName = typeName;
+		this.values = ImmutableSet.copyOf(values);
+	}
+
+	public Object parse(String str) {
+		if (values.contains(str)) {
+			return str;
+		} else {
+			throw new IllegalArgumentException("'"+str+"' is not valid for Enum '"+typeName+"'");
+		}
+	}
+
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/util/IOUtil.java

@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * Copyright (c) 2013 Pivotal Software, Inc.
+ * 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:
+ *     Pivotal Software, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.util;
+
+import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class IOUtil {
+
+	/**
+	 * Copy data from an inputstream into a file until end of the inputstream
+	 * is reached.
+	 * <p>
+	 * The input stream is closed automatically.
+	 */
+	public static void pipe(InputStream data, File target) throws IOException {
+		target.getParentFile().mkdirs(); //try to create dirs for parent if they don't exist.
+		OutputStream out = new BufferedOutputStream(new FileOutputStream(target));
+		try {
+			pipe(data, out);
+		} finally {
+			out.close();
+		}
+	}
+
+	/**
+	 * Copy input stream to output stream until end of the inputstream is reached.
+	 * The intpustream is closed automatically, but the output stream is not.
+	 */
+	public static void pipe(InputStream input, OutputStream output) throws IOException {
+		try {
+		    byte[] buf = new byte[1024*4];
+		    int n = input.read(buf);
+		    while (n >= 0) {
+		      output.write(buf, 0, n);
+		      n = input.read(buf);
+		    }
+		    output.flush();
+		} finally {
+			input.close();
+		}
+	}
+
+	public static String toString(InputStream input) throws Exception {
+		return toString(input, "UTF8");
+	}
+
+	private static String toString(InputStream input, String encoding) throws Exception {
+		ByteArrayOutputStream buf = new ByteArrayOutputStream();
+		pipe(input, buf);
+		return buf.toString(encoding);
+	}
+
+	/**
+	 * Sick and tired of writing try-catch around close calls... If something can't close, it usually means it
+	 * was already closed, no longer exists etc. This method catches and ignores the exceptions.
+	 */
+	public static void close(Closeable closeable) {
+		try {
+			closeable.close();
+		} catch (IOException e) {
+			//ignore
+		}
+	}
+
+	public static byte[] toBytes(InputStream stream) throws IOException {
+		ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+		pipe(stream, bytes);
+		return bytes.toByteArray();
+	}
+
+}

vscode-extensions/commons/yaml-commons/src/main/java/org/springframework/ide/vscode/yaml/util/ValueParser.java

@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2015-2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml.util;
+
+/**
+ * A ValueParser provides the means to Strings into some kind of
+ * value.
+ *
+ * @author Kris De Volder
+ */
+public interface ValueParser {
+	/**
+	 * Parse the string and return its parsed representation.
+	 * May either return null, or throw an {@link IllegalArgumentException} to indicate
+	 * that the String is not the format this parser expects.
+	 */
+	Object parse(String str);
+}

vscode-extensions/vscode-application-yaml/pom.xml

@@ -58,6 +58,13 @@
 			<artifactId>guava</artifactId>
 			<version>18.0</version>
 		</dependency>
+		<!-- Test harness -->
+		<dependency>
+			<groupId>org.springframework.ide.vscode</groupId>
+			<artifactId>language-server-test-harness</artifactId>
+			<version>${project.version}</version>
+			<scope>test</scope>
+		</dependency>
 	</dependencies>
 	<build>
 		<plugins>

vscode-extensions/vscode-application-yaml/src/test/java/org/springframework/ide/vscode/testharness/Editor.java

@@ -1,131 +0,0 @@
-package org.springframework.ide.vscode.testharness;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
-import javax.swing.text.BadLocationException;
-
-import io.typefox.lsapi.Diagnostic;
-import io.typefox.lsapi.Position;
-import io.typefox.lsapi.PublishDiagnosticsParams;
-import io.typefox.lsapi.Range;
-
-public class Editor {
-	
-	private static final Comparator<Diagnostic> PROBLEM_COMPARATOR = new Comparator<Diagnostic>() {
-		@Override
-		public int compare(Diagnostic o1, Diagnostic o2) {
-			int diff = compare(o1.getRange().getStart(), o2.getRange().getStart());
-			if (diff!=0) return diff;
-			return compare(o1.getRange().getEnd(), o2.getRange().getEnd());
-		}
-
-		private int compare(Position p1, Position p2) {
-			int d = p1.getLine() - p2.getLine();
-			if (d!=0) return d;
-			return p1.getCharacter() - p2.getCharacter();
-		}
-	};
-
-	private LanguageServerHarness harness;
-	private TextDocumentInfo document;
-
-	public Editor(LanguageServerHarness harness, String contents) throws Exception {
-		this.harness = harness;
-		this.document = harness.openDocument(harness.createWorkingCopy(contents));
-	}
-	
-	/**
-	 * Check that a 'expectedProblems' are found by the reconciler. Expected problems are
-	 * specified by string of the form "${badSnippet}|${messageSnippet}". The badSnippet
-	 * is the text expected to be covered by the marker's region and the message snippet must
-	 * be found in the error marker's message.
-	 * <p>
-	 * The expected problems are matched one-to-one in the order given (so markers in the
-	 * editor must appear in the expected order for the assert to pass).
-	 *
-	 * @param editor
-	 * @param expectedProblems
-	 * @throws BadLocationException
-	 */
-	public void assertProblems(String... expectedProblems) throws Exception {
-		Editor editor = this;
-		List<Diagnostic> actualProblems = new ArrayList<>(editor.reconcile());
-		Collections.sort(actualProblems, PROBLEM_COMPARATOR);
-		String bad = null;
-		if (actualProblems.size()!=expectedProblems.length) {
-			bad = "Wrong number of problems (expecting "+expectedProblems.length+" but found "+actualProblems.size()+")";
-		} else {
-			for (int i = 0; i < expectedProblems.length; i++) {
-				if (!matchProblem(editor, actualProblems.get(i), expectedProblems[i])) {
-					bad = "First mismatch at index "+i+": "+expectedProblems[i]+"\n";
-					break;
-				}
-			}
-		}
-		if (bad!=null) {
-			fail(bad+problemSumary(editor, actualProblems));
-		}
-	}
-
-	private String problemSumary(Editor editor, List<Diagnostic> actualProblems) throws Exception {
-		StringBuilder buf = new StringBuilder();
-		for (Diagnostic p : actualProblems) {
-			buf.append("\n----------------------\n");
-
-			String snippet = editor.getText(p.getRange());
-			buf.append("("+p.getRange().getStart().getLine()+", "+p.getRange().getStart().getCharacter()+")["+snippet+"]:\n");
-			buf.append("   "+p.getMessage());
-		}
-		return buf.toString();
-	}
-
-	public String getText(Range range) {
-		return document.getText(range);
-	}
-
-	public void setText(String newContent) throws Exception {
-		document = harness.changeDocument(document.getUri(), newContent);
-	}
-
-	private boolean matchProblem(Editor editor, Diagnostic problem, String expect) {
-		String[] parts = expect.split("\\|");
-		assertEquals(2, parts.length);
-		String badSnippet = parts[0];
-		String messageSnippet = parts[1];
-		boolean spaceSensitive = badSnippet.trim().length()<badSnippet.length();
-		boolean emptyRange = problem.getRange().getStart().equals(problem.getRange().getEnd());
-		String actualBadSnippet = emptyRange 
-				? editor.getCharAt(problem.getRange().getStart())
-				: editor.getText(problem.getRange());
-		if (!spaceSensitive) {
-			actualBadSnippet = actualBadSnippet.trim();
-		}
-		return actualBadSnippet.equals(badSnippet)
-				&& problem.getMessage().contains(messageSnippet);
-	}
-
-	private String getCharAt(Position start) {
-		int offset = document.toOffset(start);
-		return document.getText().substring(offset, offset+1);
-	}
-
-	@SuppressWarnings("unchecked")
-	private List<Diagnostic> reconcile() {
-		// We assume the language server works synchronously for now and it does an immediate reconcile
-		// when the document changes. In the future this is probably not going to be the case though and then this
-		// method will need to somehow ensure the linter is done working before retrieving the problems from the
-		// test harness.
-		PublishDiagnosticsParams diagnostics = harness.getDiagnostics(document);
-		if (diagnostics!=null) {
-			return (List<Diagnostic>) diagnostics.getDiagnostics();
-		}
-		return Collections.emptyList();
-	}
-
-}

vscode-extensions/vscode-manifest-yaml/lib/Main.ts

@@ -42,6 +42,7 @@ function getClasspath(context: VSCode.ExtensionContext):string {
 
 /** Called when extension is activated */
 export function activate(context: VSCode.ExtensionContext) {
+    VSCode.window.showInformationMessage("Activating manifet.yml extension");
     let javaExecutablePath = findJavaExecutable('java');
     
     if (javaExecutablePath == null) {
@@ -103,7 +104,7 @@ export function activate(context: VSCode.ExtensionContext) {
                         let args = [
                             '-Dserver.port=' + port,
                             '-cp', classpath, 
-                            'org.springframework.ide.vscode.yaml.Main'
+                            'org.springframework.ide.vscode.cloudfoundry.manifest.editor.Main'
                         ];
                         if (DEBUG) {
                             args.unshift(DEBUG_ARG);

vscode-extensions/vscode-manifest-yaml/pom.xml

@@ -34,19 +34,20 @@
 		<dependency>
 			<groupId>org.springframework.ide.vscode</groupId>
 			<artifactId>language-server-commons</artifactId>
-			<version>0.0.1-SNAPSHOT</version>
+			<version>${project.version}</version>
 		</dependency>
 		<!-- Yaml -->
 		<dependency>
-			<groupId>org.yaml</groupId>
-			<artifactId>snakeyaml</artifactId>
-			<version>1.17</version>
+			<groupId>org.springframework.ide.vscode</groupId>
+			<artifactId>yaml-commons</artifactId>
+			<version>${project.version}</version>
 		</dependency>
-		<!-- Guava collections -->
+		<!-- Test harness -->
 		<dependency>
-			<groupId>com.google.guava</groupId>
-			<artifactId>guava</artifactId>
-			<version>18.0</version>
+			<groupId>org.springframework.ide.vscode</groupId>
+			<artifactId>language-server-test-harness</artifactId>
+			<version>${project.version}</version>
+			<scope>test</scope>
 		</dependency>
 	</dependencies>
 	<build>

vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/cloudfoundry/manifest/editor/Main.java

@@ -1,4 +1,4 @@
-package org.springframework.ide.vscode.yaml;
+package org.springframework.ide.vscode.cloudfoundry.manifest.editor;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -79,7 +79,7 @@ public class Main {
      * When the request stream is closed, wait for 5s for all outstanding responses to compute, then return.
      */
     public static void run(Connection connection) {
-    	YamlLanguageServer server = new YamlLanguageServer();
+    	ManifestYamlLanguageServer server = new ManifestYamlLanguageServer();
     	LoggingJsonAdapter jsonServer = new LoggingJsonAdapter(server);
     	jsonServer.setMessageLog(new PrintWriter(System.out));
 

vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/cloudfoundry/manifest/editor/ManifestYamlLanguageServer.java

@@ -1,15 +1,28 @@
-package org.springframework.ide.vscode.yaml;
+package org.springframework.ide.vscode.cloudfoundry.manifest.editor;
 
 import java.io.StringReader;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
+import javax.inject.Provider;
+
+import org.springframework.ide.vscode.commons.reconcile.IDocument;
+import org.springframework.ide.vscode.commons.reconcile.IProblemCollector;
+import org.springframework.ide.vscode.commons.reconcile.ReconcileProblem;
 import org.springframework.ide.vscode.util.Futures;
 import org.springframework.ide.vscode.util.SimpleLanguageServer;
 import org.springframework.ide.vscode.util.SimpleTextDocumentService;
 import org.springframework.ide.vscode.util.TextDocument;
+import org.springframework.ide.vscode.yaml.ErrorCodes;
+import org.springframework.ide.vscode.yaml.ast.YamlASTProvider;
+import org.springframework.ide.vscode.yaml.reconcile.SchemaBasedYamlASTReconciler;
+import org.springframework.ide.vscode.yaml.reconcile.YamlASTReconciler;
+import org.springframework.ide.vscode.yaml.reconcile.YamlSchemaBasedReconcileEngine;
+import org.springframework.ide.vscode.yaml.schema.YValueHint;
+import org.springframework.ide.vscode.yaml.schema.YamlSchema;
 import org.yaml.snakeyaml.Yaml;
 import org.yaml.snakeyaml.error.MarkedYAMLException;
 import org.yaml.snakeyaml.error.YAMLException;
@@ -29,15 +42,17 @@ import io.typefox.lsapi.RangeImpl;
 import io.typefox.lsapi.ServerCapabilities;
 import io.typefox.lsapi.ServerCapabilitiesImpl;
 
-public class YamlLanguageServer extends SimpleLanguageServer {
+public class ManifestYamlLanguageServer extends SimpleLanguageServer {
 
+	private static final Provider<Collection<YValueHint>> NO_BUILDPACKS = () -> ImmutableList.of();
+	
 	private Yaml yaml = new Yaml();
 	
-	public YamlLanguageServer() {
+	public ManifestYamlLanguageServer() {
 		SimpleTextDocumentService documents = getTextDocumentService();
+
 //		SimpleWorkspaceService workspace = getWorkspaceService();
 		documents.onDidChangeContent(params -> {
-			System.out.println("Document changed: "+params);
 			TextDocument doc = params.getDocument();
 			validateDocument(documents, doc);
 		});
@@ -104,55 +119,36 @@ public class YamlLanguageServer extends SimpleLanguageServer {
 	}
 
 	private void validateDocument(SimpleTextDocumentService documents, TextDocument doc) {
-		List<DiagnosticImpl> diagnostics = reconcile(documents, doc);
-		documents.publishDiagnostics(doc, diagnostics);
+		IProblemCollector problems = new IProblemCollector() {
+			
+			private List<DiagnosticImpl> diagnostics = new ArrayList<>();
+			
+			@Override
+			public void endCollecting() {
+				documents.publishDiagnostics(doc, diagnostics);
+			}
+			
+			@Override
+			public void beginCollecting() {
+				diagnostics.clear();
+			}
+			
+			@Override
+			public void accept(ReconcileProblem problem) {
+				DiagnosticImpl d = new DiagnosticImpl();
+				d.setCode(problem.getCode());
+				d.setMessage(problem.getMessage());
+				d.setRange(doc.toRange(problem.getOffset(), problem.getLength()));
+				diagnostics.add(d);
+			}
+		};
+		
+		YamlSchema schema = new ManifestYmlSchema(NO_BUILDPACKS);
+		YamlASTProvider parser = new YamlParser(yaml);
+		YamlSchemaBasedReconcileEngine engine = new YamlSchemaBasedReconcileEngine(parser, schema);
+		engine.reconcile(doc, problems);
 	}
 	
-	protected List<DiagnosticImpl> reconcile(SimpleTextDocumentService documents, TextDocument doc) {
-		try {
-			Iterator<Node> asts = yaml.composeAll(new StringReader(doc.getText())).iterator();
-			while (asts.hasNext()) {
-				asts.next();
-			}
-			return ImmutableList.of();
-		} catch (YAMLException e) {
-			return ImmutableList.of(parseError(e));
-		}
-	}
-
-	private DiagnosticImpl parseError(YAMLException e) {
-		DiagnosticImpl d = new DiagnosticImpl();
-		d.setMessage(getMessage(e));
-		d.setRange(getRange(e));
-		d.setSeverity(Diagnostic.SEVERITY_ERROR);
-		d.setCode(ErrorCodes.YAML_SYNTAX_ERROR);
-		d.setSource("yaml");
-		return d;
-	}
-
-	private String getMessage(YAMLException e) {
-		if (e instanceof MarkedYAMLException) {
-			return ((MarkedYAMLException) e).getProblem();
-		}
-		return e.getMessage();
-	}
-
-	private RangeImpl getRange(YAMLException _e) {
-		if (_e instanceof MarkedYAMLException) {
-			MarkedYAMLException e = (MarkedYAMLException) _e;
-
-			PositionImpl start = new PositionImpl();
-			start.setLine(e.getProblemMark().getLine());
-			start.setCharacter(e.getProblemMark().getColumn());
-			
-			RangeImpl rng = new RangeImpl();
-			rng.setStart(start);
-			rng.setEnd(start);
-			return rng;
-		}
-		return null;
-	}
-
 	@Override
 	protected ServerCapabilitiesImpl getServerCapabilities() {
 		ServerCapabilitiesImpl c = new ServerCapabilitiesImpl();

vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/cloudfoundry/manifest/editor/ManifestYmlSchema.java

@@ -0,0 +1,126 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.cloudfoundry.manifest.editor;
+
+import java.util.Collection;
+import java.util.Set;
+
+import javax.inject.Provider;
+
+import org.springframework.ide.vscode.yaml.schema.YType;
+import org.springframework.ide.vscode.yaml.schema.YTypeFactory;
+import org.springframework.ide.vscode.yaml.schema.YTypeFactory.YAtomicType;
+import org.springframework.ide.vscode.yaml.schema.YTypeFactory.YBeanType;
+import org.springframework.ide.vscode.yaml.schema.YTypeFactory.YTypedPropertyImpl;
+import org.springframework.ide.vscode.yaml.schema.YTypeUtil;
+import org.springframework.ide.vscode.yaml.schema.YValueHint;
+import org.springframework.ide.vscode.yaml.schema.YamlSchema;
+import org.springframework.ide.vscode.yaml.util.Description;
+import org.springframework.ide.vscode.yaml.util.DescriptionProviders;
+
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * @author Kris De Volder
+ */
+public class ManifestYmlSchema implements YamlSchema {
+
+	private final YBeanType TOPLEVEL_TYPE;
+	private final YTypeUtil TYPE_UTIL;
+	private final Provider<Collection<YValueHint>> buildpackProvider;
+
+	private static final Set<String> TOPLEVEL_EXCLUDED = ImmutableSet.of(
+		"name", "host", "hosts"
+	);
+
+	public ManifestYmlSchema(Provider<Collection<YValueHint>> buildpackProvider) {
+		this.buildpackProvider = buildpackProvider;
+		YTypeFactory f = new YTypeFactory();
+		TYPE_UTIL = f.TYPE_UTIL;
+
+		// define schema types
+		TOPLEVEL_TYPE = f.ybean("manifest.yml schema");
+
+		YBeanType application = f.ybean("Application");
+		YAtomicType t_path = f.yatomic("Path");
+
+		YAtomicType t_buildpack = f.yatomic("Buildpack");
+		
+		t_buildpack.addHintProvider(this.buildpackProvider);
+
+		YAtomicType t_boolean = f.yenum("boolean", "true", "false");
+		YType t_string = f.yatomic("String");
+		YType t_strings = f.yseq(t_string);
+
+		YAtomicType t_memory = f.yatomic("Memory");
+		t_memory.addHints("256M", "512M", "1024M");
+		t_memory.parseWith(ManifestYmlValueParsers.MEMORY);
+
+		YAtomicType t_strictly_pos_integer = f.yatomic("Strictly Positive Integer");
+		t_strictly_pos_integer.parseWith(ManifestYmlValueParsers.integerAtLeast(1));
+
+		YAtomicType t_pos_integer = f.yatomic("Positive Integer");
+		t_pos_integer.parseWith(ManifestYmlValueParsers.POS_INTEGER);
+
+		YType t_env = f.ymap(t_string, t_string);
+
+		// define schema structure...
+		TOPLEVEL_TYPE.addProperty("applications", f.yseq(application));
+		TOPLEVEL_TYPE.addProperty("inherit", t_string, descriptionFor("inherit"));
+
+		YTypedPropertyImpl[] props = {
+			f.yprop("buildpack", t_buildpack),
+			f.yprop("command", t_string),
+			f.yprop("disk_quota", t_memory),
+			f.yprop("domain", t_string),
+			f.yprop("domains", t_strings),
+			f.yprop("env", t_env),
+			f.yprop("host", t_string),
+			f.yprop("hosts", t_strings),
+			f.yprop("instances", t_strictly_pos_integer),
+			f.yprop("memory", t_memory),
+			f.yprop("name", t_string),
+			f.yprop("no-hostname", t_boolean),
+			f.yprop("no-route", t_boolean),
+			f.yprop("path", t_path),
+			f.yprop("random-route", t_boolean),
+			f.yprop("services", t_strings),
+			f.yprop("stack", t_string),
+			f.yprop("timeout", t_pos_integer)
+		};
+
+		for (YTypedPropertyImpl prop : props) {
+			prop.setDescriptionProvider(descriptionFor(prop));
+			if (!TOPLEVEL_EXCLUDED.contains(prop.getName())) {
+				TOPLEVEL_TYPE.addProperty(prop);
+			}
+			application.addProperty(prop);
+		}
+	}
+
+	private Provider<Description> descriptionFor(String propName) {
+		return DescriptionProviders.fromClasspath(this.getClass(), "/description-by-prop-name/"+propName+".html");
+	}
+
+	private Provider<Description> descriptionFor(YTypedPropertyImpl prop) {
+		return descriptionFor(prop.getName());
+	}
+
+	@Override
+	public YBeanType getTopLevelType() {
+		return TOPLEVEL_TYPE;
+	}
+
+	@Override
+	public YTypeUtil getTypeUtil() {
+		return TYPE_UTIL;
+	}
+}

vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/cloudfoundry/manifest/editor/ManifestYmlValueParsers.java

@@ -0,0 +1,90 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.cloudfoundry.manifest.editor;
+
+import java.util.Set;
+
+import org.springframework.ide.vscode.util.Assert;
+import org.springframework.ide.vscode.yaml.util.ValueParser;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+
+/**
+ * Methods and constants to create/get parsers for some atomic types
+ * used in manifest yml schema.
+ *
+ * @author Kris De Volder
+ */
+public class ManifestYmlValueParsers {
+
+	public static final ValueParser POS_INTEGER = integerRange(0, null);
+
+	public static final ValueParser MEMORY = new ValueParser() {
+
+		private final ImmutableSet<String> GIGABYTE = ImmutableSet.of("G", "GB");
+		private final ImmutableSet<String> MEGABYTE = ImmutableSet.of("M", "MB");
+		private final Set<String> UNITS = Sets.union(GIGABYTE, MEGABYTE);
+
+		@Override
+		public Object parse(String str) {
+			str = str.trim();
+			String unit = getUnit(str.toUpperCase());
+			if (unit==null) {
+				throw new NumberFormatException(
+						"'"+str+"' doesn't end with a valid unit of memory ('M', 'MB', 'G' or 'GB')"
+				);
+			}
+			str = str.substring(0, str.length()-unit.length());
+			int unitSize = GIGABYTE.contains(unit)?1024:1;
+			int value = Integer.parseInt(str);
+			if (value<0) {
+				throw new NumberFormatException("Negative value is not allowed");
+			}
+			return value * unitSize;
+		}
+
+		private String getUnit(String str) {
+			for (String u : UNITS) {
+				if (str.endsWith(u)) {
+					return u;
+				}
+			}
+			return null;
+		}
+	};
+
+	public static ValueParser integerAtLeast(final Integer lowerBound) {
+		return integerRange(lowerBound, null);
+	}
+
+	public static ValueParser integerRange(final Integer lowerBound, final Integer upperBound) {
+		Assert.isLegal(lowerBound==null || upperBound==null || lowerBound <= upperBound);
+		return new ValueParser() {
+			@Override
+			public Object parse(String str) {
+				int value = Integer.parseInt(str);
+				if (lowerBound!=null && value<lowerBound) {
+					if (lowerBound==0) {
+						throw new NumberFormatException("Value must be positive");
+					} else {
+						throw new NumberFormatException("Value must be at least "+lowerBound);
+					}
+				}
+				if (upperBound!=null && value>upperBound) {
+					throw new NumberFormatException("Value must be at most "+upperBound);
+				}
+				return value;
+			}
+		};
+	}
+
+}

vscode-extensions/vscode-manifest-yaml/src/main/java/org/springframework/ide/vscode/cloudfoundry/manifest/editor/YamlParser.java

@@ -0,0 +1,23 @@
+package org.springframework.ide.vscode.cloudfoundry.manifest.editor;
+
+import java.io.StringReader;
+
+import org.springframework.ide.vscode.commons.reconcile.IDocument;
+import org.springframework.ide.vscode.yaml.ast.YamlASTProvider;
+import org.springframework.ide.vscode.yaml.ast.YamlFileAST;
+import org.yaml.snakeyaml.Yaml;
+
+public class YamlParser implements YamlASTProvider {
+
+	private Yaml yaml;
+
+	public YamlParser(Yaml yaml) {
+		this.yaml = yaml;
+	}
+
+	@Override
+	public YamlFileAST getAST(IDocument doc) throws Exception {
+		return new YamlFileAST(yaml.composeAll(new StringReader(doc.get())));
+	}
+
+}

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/buildpack.html

@@ -0,0 +1,11 @@
+<p>If your application requires a custom buildpack, you can use the <code>buildpack</code> attribute to specify its URL or name:</p>
+
+<pre>
+---
+  ...
+  buildpack: buildpack_URL
+</pre>
+
+<p class="note"><strong>Note</strong>: The <code>cf buildpacks</code> command lists the buildpacks that you can refer to by name in a manifest or a command line option.</p>
+
+<p>The command line option that overrides this attribute is <code>-b</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/command.html

@@ -0,0 +1,34 @@
+<p>Some languages and frameworks require that you provide a custom command to start an application. Refer to the <a href="/buildpacks/">buildpack</a> documentation to determine if you need to provide a custom start command.</p>
+
+<p>You can provide the custom start command in your application manifest or on the command line.</p>
+
+<p>To specify the custom start command in your application manifest, add it in the <code>command: START-COMMAND</code> format as the following example shows:</p>
+
+<pre>
+---
+  ...
+  command: bundle exec rake VERBOSE=true
+</pre>
+
+<p>On the command line, use the <code>-c</code> option to specify the custom start command as the following example shows:</p>
+
+<pre class="terminal">
+$ cf push my-app -c "bundle exec rake VERBOSE=true"
+</pre>
+
+<p class="note"><strong>Note</strong>: The <code>-c</code> option with a value of &lsquo;null&rsquo; forces <code>cf push</code> to use the buildpack start command. See <a href="./app-startup.html">About Starting Applications</a> for more information.</p>
+
+<p>If you override the start command for a Buildpack application, Linux uses 
+<code>bash -c YOUR-COMMAND</code> to invoke your application.
+If you override the start command for a Docker application, Linux uses <code>sh -c YOUR-COMMAND</code> to invoke your application.
+Because of this, if you override a start command, you should prefix <code>exec</code> to the final command in your custom composite start command.</p>
+
+<p><code>exec</code> causes the last command to become the root process of your application. The <a href="./prepare-to-deploy.html#moving-apps">Cloud Foundry Updates and Your Application</a> section of the <em>Considerations for Designing and Running an Application in the Cloud</em> topic explains why your application should handle a <code>termination signal</code> during Cloud Foundry updates. 
+Without an <code>exec</code> statement, the parent process remains as the implied bash process, and does not propagate signals to your application process.</p>
+
+<p>For example, both of the following composite start commands run database migrations when the first instance of the app starts, then start the app to serve requests, but they behave differently on graceful shutdown. </p>
+
+<ul>
+<li><p><code>bin/rake cf:on_first_instance db:migrate &amp;&amp; bin/rails server -p $PORT -e $RAILS_ENV</code>: The process tree is <code>bash -&gt; ruby</code>, so on graceful shutdown only the <code>bash</code> process receives the TERM signal, and not the <code>ruby</code> process.</p></li>
+<li><p><code>bin/rake cf:on_first_instance db:migrate &amp;&amp; exec bin/rails server -p $PORT -e $RAILS_ENV</code>: Because of the <code>exec</code> prefix on the final command, the <code>ruby</code> process invoked by <code>rails</code> takes over the <code>bash</code> process managing the execution of the composite command. The process tree is only <code>ruby</code>, so the ruby web server receives the TERM signal can shutdown gracefully for 10 seconds.</p></li>
+</ul>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/disk_quota.html

@@ -0,0 +1,9 @@
+<p>Use the <code>disk_quota</code> attribute to allocate the disk space for your app instance. This attribute requires a unit of measurement: <code>M</code>, <code>MB</code>, <code>G</code>, or <code>GB</code>, in upper case or lower case.</p>
+
+<pre>
+---
+  ...
+  disk_quota: 1024M
+</pre>
+
+<p>The command line option that overrides this attribute is <code>-k</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/domain.html

@@ -0,0 +1,27 @@
+<p>Every <code>cf push</code> deploys applications to one particular Cloud Foundry instance.
+Every Cloud Foundry instance may have a shared domain set by an admin.
+Unless you specify a domain, Cloud Foundry incorporates that shared domain in the route to your application.</p>
+
+<p>You can use the <code>domain</code> attribute when you want your application to be served from a domain other than the default shared domain.</p>
+
+<pre>
+---
+  ...
+  domain: unique-example.com
+</pre>
+
+<p>The command line option that overrides this attribute is <code>-d</code>.</p>
+
+<h3><a id='domains'></a>The domains attribute</h3>
+
+<p>Use the <code>domains</code> attribute to provide multiple domains. If you define both <code>domain</code> and <code>domains</code> attributes, Cloud Foundry creates routes for domains defined in both of these fields.</p>
+
+<pre>
+---
+  ...
+  domains:
+  - domain-example1.com
+  - domain-example2.org
+</pre>
+
+<p>The command line option that overrides this attribute is <code>-d</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/domains.html

@@ -0,0 +1,10 @@
+<p>Use the <code>domains</code> attribute to provide multiple domains. If you define both <code>domain</code> and <code>domains</code> attributes, Cloud Foundry creates routes for domains defined in both of these fields.</p>
+
+<pre>---
+  ...
+  domains:
+  - domain-example1.com
+  - domain-example2.org
+</pre>
+
+<p>The command line option that overrides this attribute is <code>-d</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/env.html

@@ -0,0 +1,28 @@
+<p>The <code>env</code> block consists of a heading, then one or more environment variable/value pairs.</p>
+
+<p>For example:</p>
+
+<pre>
+---
+  ...
+  env:
+    RAILS_ENV: production
+    RACK_ENV: production
+</pre>
+
+<p><code>cf push</code> deploys the application to a container on the server. The variables belong to the container environment.</p>
+
+<p>While the application is running, Cloud Foundry allows you to operate on environment variables.</p>
+
+<ul>
+<li>View all variables: <code>cf env my-app</code></li>
+<li>Set an individual variable: <code>cf set-env my-app my-variable_name my-variable_value</code></li>
+<li>Unset an individual variable: <code>cf unset-env my-app my-variable_name my-variable_value</code></li>
+</ul>
+
+<p>Environment variables interact with manifests in the following ways:</p>
+
+<ul>
+<li><p>When you deploy an application for the first time, Cloud Foundry reads the variables described in the environment block of the manifest, and adds them to the environment of the container where the application is deployed.</p></li>
+<li><p>When you stop and then restart an application, its environment variables persist.</p></li>
+</ul>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/host.html

@@ -0,0 +1,9 @@
+<p>Use the <code>host</code> attribute to provide a hostname, or subdomain, in the form of a string. This segment of a route helps to ensure that the route is unique. If you do not provide a hostname, the URL for the app takes the form of <code>APP-NAME.DOMAIN</code>.</p>
+
+<pre>
+---
+  ...
+  host: my-app
+</pre>
+
+<p>The command line option that overrides this attribute is <code>-n</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/hosts.html

@@ -0,0 +1,11 @@
+<p>Use the <code>hosts</code> attribute to provide multiple hostnames, or subdomains. Each hostname generates a unique route for the app. <code>hosts</code> can be used in conjunction with <code>host</code>. If you define both attributes, Cloud Foundry creates routes for hostnames defined in both <code>host</code> and <code>hosts</code>.</p>
+
+<pre>
+---
+  ...
+  hosts:
+  - app_host1
+  - app_host2
+</pre>
+
+<p>The command line option that overrides this attribute is <code>-n</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/inherit.html

@@ -0,0 +1,62 @@
+<p>A single manifest can describe multiple applications. Another powerful technique is to create multiple manifests with inheritance. Here, manifests have parent-child relationships such that children inherit descriptions from a parent. Children can use inherited descriptions as-is, extend them, or override them.</p>
+
+<p>Content in the child manifest overrides content in the parent manifest, if the two conflict.</p>
+
+<p>This technique helps in these and other scenarios:</p>
+
+<ul>
+<li><p>An application has a set of different deployment modes, such as debug, local, and public. Each deployment mode is described in child manifests that extend the settings in a base parent manifest.</p></li>
+<li><p>An application is packaged with a basic configuration described by a parent manifest. Users can extend the basic configuration by creating child manifests that add new properties or override those in the parent manifest.</p></li>
+</ul>
+
+<p>The benefits of multiple manifests with inheritance are similar to those of minimizing duplicated content within single manifests. With inheritance, though, we “promote” content by placing it in the parent manifest.</p>
+
+<p>Every child manifest must contain an “inherit” line that points to the parent manifest. Place the inherit line immediately after the three dashes at the top of the child manifest. For example, every child of a parent manifest called <code>base-manifest.yml</code> begins like this:</p>
+
+<pre>---
+  ...
+  inherit: base-manifest.yml
+</pre>
+
+<p>You do not need to add anything to the parent manifest.</p>
+
+<p>In the simple example below, a parent manifest gives each application minimal resources, while a production child manifest scales them up.</p>
+
+<p><strong>simple-base-manifest.yml</strong></p>
+
+<pre>---
+path: .
+domain: shared-domain.com
+memory: 256M
+instances: 1
+services:
+- singular-backend
+
+# app-specific configuration
+applications:
+ - name: springtock
+   host: 765shower
+   path: ./april/build/libs/april-weather.war
+ - name: wintertick
+   host: 321flurry
+   path: ./december/target/december-weather.war
+</pre>
+
+<p><strong>simple-prod-manifest.yml</strong></p>
+
+<pre>---
+inherit: simple-base-manifest.yml
+applications:
+ - name:springstorm
+   memory: 512M
+   instances: 1
+   host: 765deluge
+   path: ./april/build/libs/april-weather.war
+ - name: winterblast
+   memory: 1G
+   instances: 2
+   host: 321blizzard
+   path: ./december/target/december-weather.war
+</pre>
+
+<p><class='note'><strong>Note</strong>: Inheritance can add an additional level of complexity to manifest creation and maintenance. Comments that precisely explain how the child manifest extends or overrides the descriptions in the parent manifest can alleviate this complexity.</class='note'>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/instances.html

@@ -0,0 +1,11 @@
+<p>Use the <code>instances</code> attribute to specify the number of app instances that you want to start upon push:</p>
+
+<pre>
+---
+  ...
+  instances: 2
+</pre>
+
+<p>We recommend that you run at least two instances of any apps for which fault tolerance matters.</p>
+
+<p>The command line option that overrides this attribute is <code>-i</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/memory.html

@@ -0,0 +1,11 @@
+<p>Use the <code>memory</code> attribute to specify the memory limit for all instances of an app. This attribute requires a unit of measurement: <code>M</code>, <code>MB</code>, <code>G</code>, or <code>GB</code>, in upper case or lower case. For example:</p>
+
+<pre>
+---
+  ...
+  memory: 1024M
+</pre>
+
+<p>The default memory limit is 1G. You might want to specify a smaller limit to conserve quota space if you know that your app instances do not require 1G of memory.</p>
+
+<p>The command line option that overrides this attribute is <code>-m</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/name.html

@@ -0,0 +1,10 @@
+<p>The <code>name</code> attribute is the only required attribute 
+for an application in a manifest file. </p>
+
+<p>This is an example of a minimal manifest:</p>
+
+<pre>
+---
+applications:
+- name: nifty-gui
+</pre>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/no-hostname.html

@@ -0,0 +1,9 @@
+<p>By default, if you do not provide a hostname, the URL for the app takes the form of <code>APP-NAME.DOMAIN</code>. If you want to override this and map the root domain to this app then you can set no-hostname as true.</p>
+
+<pre>
+---
+  ...
+  no-hostname: true
+</pre>
+
+<p>The command line option that corresponds to this attribute is <code>--no-hostname</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/no-route.html

@@ -0,0 +1,18 @@
+<p>By default, <code>cf push</code> assigns a route to every application. But some applications process data while running in the background, and should not be assigned routes.</p>
+
+<p>You can use the <code>no-route</code> attribute with a value of <code>true</code> to prevent a route from being created for your application.</p>
+
+<pre>
+---
+  ...
+  no-route: true
+</pre>
+
+<p>The command line option that corresponds to this attribute is <code>--no-route</code>.</p>
+
+<p>If you find that an application which should not have a route does have one:</p>
+
+<ol>
+<li>Remove the route using the <code>cf unmap-route</code> command.</li>
+<li>Push the app again with the <code>no-route: true</code> attribute in the manifest or the <code>--no-route</code> command line option.</li>
+</ol>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/path.html

@@ -0,0 +1,9 @@
+<p>You can use the <code>path</code> attribute to tell Cloud Foundry where to find your application. This is generally not necessary when you run <code>cf push</code> from the directory where an application is located.</p>
+
+<pre>
+---
+  ...
+  path: path_to_application_bits
+</pre>
+
+<p>The command line option that overrides this attribute is <code>-p</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/random-route.html

@@ -0,0 +1,11 @@
+<p>Use the <code>random-route</code> attribute to create a URL that includes the app name and
+random words.
+Use this attribute to avoid URL collision when pushing the same app to multiple spaces, or to avoid managing app URLs.</p>
+
+<p>The command line option that corresponds to this attribute is <code>--random-route</code>.</p>
+
+<pre>
+---
+  ...
+  random-route: true
+</pre>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/services.html

@@ -0,0 +1,18 @@
+<p>Applications can bind to services such as databases, messaging, and key-value stores.</p>
+
+<p>Applications are deployed into App Spaces. An application can only bind to services instances that exist in the target App Space before the application is deployed.</p>
+
+<p>The <code>services</code> block consists of a heading, then one or more service instance names.</p>
+
+<p>Whoever creates the service chooses the service instance names. These names can convey logical information, as in <code>backend_queue</code>, describe the nature of the service, as in <code>mysql_5.x</code>, or do neither, as in the example below.</p>
+
+<pre>
+---
+  ...
+  services:
+   - instance_ABC
+   - instance_XYZ
+</pre>
+
+<p>Binding to a service instance is a special case of setting an environment 
+variable, namely <code>VCAP_SERVICES</code>.

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/stack.html

@@ -0,0 +1,11 @@
+<p>Use the <code>stack</code> attribute to specify which stack to deploy your application to.</p>
+
+<p>To see a list of available stacks, run <code>cf stacks</code> from the cf cli.</p>
+
+<pre>
+---
+  ...
+  stack: cflinuxfs2
+</pre>
+
+<p>The command line option that overrides this attribute is <code>-s</code>.</p>

vscode-extensions/vscode-manifest-yaml/src/main/resources/description-by-prop-name/timeout.html

@@ -0,0 +1,14 @@
+<p>The <code>timeout</code> attribute defines the number of seconds Cloud Foundry allocates for starting your application. </p>
+
+<p>For example:</p>
+
+<pre>
+---
+  ...
+  timeout: 80
+</pre>
+
+<p>You can increase the timeout length for very large apps that require more time to start. The default timeout is 60 seconds with an upper bound of 180 seconds.</p>
+<p class="note"><strong>Note</strong>: Administrators can set the upper bound of the <code>maximum_health_check_timeout</code> property to any value. Any changes to Cloud Controller properties in the deployment manifest require running <code>bosh deploy</code>.</p>
+
+<p>The command line option that overrides the timeout attribute for the shell is <code>-t</code>. Manifest values still apply to applications pushed to the deployment.</p>

vscode-extensions/vscode-manifest-yaml/src/test/java/org/springframework/ide/vscode/testharness/LanguageServerHarness.java

@@ -1,246 +0,0 @@
-package org.springframework.ide.vscode.testharness;
-
-import java.io.File;
-import java.nio.charset.Charset;
-import java.nio.file.Files;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Random;
-import java.util.concurrent.Callable;
-import java.util.stream.Collectors;
-
-import org.assertj.core.api.Condition;
-
-import io.typefox.lsapi.ClientCapabilitiesImpl;
-import io.typefox.lsapi.CompletionItem;
-import io.typefox.lsapi.CompletionList;
-import io.typefox.lsapi.Diagnostic;
-import io.typefox.lsapi.DidChangeTextDocumentParamsImpl;
-import io.typefox.lsapi.DidOpenTextDocumentParamsImpl;
-import io.typefox.lsapi.InitializeParamsImpl;
-import io.typefox.lsapi.InitializeResult;
-import io.typefox.lsapi.Position;
-import io.typefox.lsapi.PositionImpl;
-import io.typefox.lsapi.PublishDiagnosticsParams;
-import io.typefox.lsapi.Range;
-import io.typefox.lsapi.ServerCapabilities;
-import io.typefox.lsapi.TextDocumentContentChangeEventImpl;
-import io.typefox.lsapi.TextDocumentItemImpl;
-import io.typefox.lsapi.TextDocumentPositionParamsImpl;
-import io.typefox.lsapi.VersionedTextDocumentIdentifierImpl;
-import io.typefox.lsapi.services.LanguageServer;
-
-public class LanguageServerHarness {
-
-	//Warning this 'harness' is not very good yet. It just implements bare minimum to
-	// be able to test the MyLanguageServer example. 
-
-	private Random random = new Random();
-
-	private Callable<? extends LanguageServer> factory;
-
-	private LanguageServer server;
-
-	private InitializeResult initResult;
-	
-	private Map<String,TextDocumentInfo> documents = new HashMap<>();
-	private Map<String, PublishDiagnosticsParams> diagnostics = new HashMap<>();
-
-	public LanguageServerHarness(Callable<? extends LanguageServer> factory) throws Exception {
-		this.factory = factory;
-	}
-
-	public synchronized TextDocumentInfo getOrReadFile(File file) throws Exception {
-		String uri = file.toURI().toString();
-		TextDocumentInfo d = documents.get(uri);
-		if (d==null) {
-			documents.put(uri, d = readFile(file));
-		}
-		return d;
-	}
-
-	public TextDocumentInfo readFile(File file) throws Exception {
-		byte[] encoded = Files.readAllBytes(file.toPath());
-		String content = new String(encoded, getEncoding());
-		TextDocumentItemImpl document = new TextDocumentItemImpl();
-		document.setText(content);
-		document.setUri(file.toURI().toString());
-		document.setVersion(getFirstVersion());
-		document.setLanguageId(getLanguageId());
-		return new TextDocumentInfo(document);
-	}
-	
-	private synchronized TextDocumentItemImpl setDocumentContent(String uri, String newContent) {
-		TextDocumentInfo o = documents.get(uri);
-		TextDocumentItemImpl n = new TextDocumentItemImpl();
-		n.setLanguageId(o.getLanguageId());
-		n.setText(newContent);
-		n.setVersion(o.getVersion()+1);
-		n.setUri(o.getUri());
-		documents.put(uri, new TextDocumentInfo(n));
-		return n;
-	}
-
-	protected Charset getEncoding() {
-		return Charset.forName("utf8");
-	}
-
-	protected String getLanguageId() {
-		return "plaintext";
-	}
-	
-	protected String getFileExtension() {
-		return ".txt";
-	}
-	
-	private synchronized void receiveDiagnostics(PublishDiagnosticsParams diags) {
-		this.diagnostics.put(diags.getUri(), diags);
-	}
-
-	public InitializeResult intialize(File workspaceRoot) throws Exception {
-		server = factory.call();
-		int parentPid = random.nextInt(40000)+1000;
-		InitializeParamsImpl initParams = new InitializeParamsImpl();
-		initParams.setRootPath(workspaceRoot== null?null:workspaceRoot.toString());
-		initParams.setProcessId(parentPid);
-		ClientCapabilitiesImpl clientCap = new ClientCapabilitiesImpl();
-		initParams.setCapabilities(clientCap);
-		initResult = server.initialize(initParams).get();
-		
-		server.getTextDocumentService().onPublishDiagnostics(this::receiveDiagnostics);
-		return initResult;
-	}
-
-	public TextDocumentInfo openDocument(TextDocumentInfo documentInfo) throws Exception {
-		DidOpenTextDocumentParamsImpl didOpen = new DidOpenTextDocumentParamsImpl();
-		didOpen.setTextDocument(documentInfo.getDocument());
-		didOpen.setText(documentInfo.getText());
-		didOpen.setUri(documentInfo.getUri());
-		server.getTextDocumentService().didOpen(didOpen);
-		return documentInfo;
-	}
-	
-	public TextDocumentInfo openDocument(File file) throws Exception {
-		return openDocument(getOrReadFile(file));
-	}
-
-	public TextDocumentInfo changeDocument(String uri, String newContent) throws Exception {
-		TextDocumentItemImpl textDocument = setDocumentContent(uri, newContent);
-		DidChangeTextDocumentParamsImpl didChange = new DidChangeTextDocumentParamsImpl();
-		VersionedTextDocumentIdentifierImpl version = new VersionedTextDocumentIdentifierImpl();
-		version.setUri(uri);
-		version.setVersion(textDocument.getVersion());
-		didChange.setTextDocument(version);
-		switch (getDocumentSyncMode()) {
-		case ServerCapabilities.SYNC_NONE:
-			break; //nothing todo
-		case ServerCapabilities.SYNC_INCREMENTAL:
-			throw new IllegalStateException("Incremental sync not yet supported by this test harness");
-		case ServerCapabilities.SYNC_FULL:
-			TextDocumentContentChangeEventImpl change = new TextDocumentContentChangeEventImpl();
-			change.setText(newContent);
-			didChange.setContentChanges(Collections.singletonList(change));
-			break;
-		default:
-			throw new IllegalStateException("Unkown SYNC mode: "+getDocumentSyncMode());
-		}
-		server.getTextDocumentService().didChange(didChange);
-		return documents.get(uri);
-	}
-
-	private int getDocumentSyncMode() {
-		Integer mode = initResult.getCapabilities().getTextDocumentSync();
-		return mode==null ? ServerCapabilities.SYNC_NONE : mode;
-	}
-
-	public PublishDiagnosticsParams getDiagnostics(TextDocumentInfo doc) {
-		return diagnostics.get(doc.getUri());
-	}
-	
-	public static Condition<Diagnostic> isDiagnosticWithSeverity(int severity) {
-		return new Condition<>(
-				(d) -> d.getSeverity()==severity,
-				"Diagnostic with severity '"+severity+"'"
-		); 
-	}
-
-	public static Condition<Diagnostic> isDiagnosticCovering(TextDocumentInfo doc, String string) {
-		return new Condition<>(
-				(d) -> isDiagnosticCovering(d, doc, string),
-				"Diagnostic covering '"+string+"'"
-		); 
-	}
-
-	public static final Condition<Diagnostic> isWarning = isDiagnosticWithSeverity(Diagnostic.SEVERITY_WARNING);
-
-	public static boolean isDiagnosticCovering(Diagnostic diag, TextDocumentInfo doc, String string) {
-		Range rng = diag.getRange();
-		String actualText = doc.getText(rng);
-		return string.equals(actualText);
-	}
-
-	public static Condition<Diagnostic> isDiagnosticOnLine(int line) {
-		return new Condition<>(
-				(d) -> d.getRange().getStart().getLine()==line,
-				"Diagnostic on line "+line
-		); 
-	}
-
-	public CompletionList getCompletions(TextDocumentInfo doc, Position cursor) throws Exception {
-		TextDocumentPositionParamsImpl params = new TextDocumentPositionParamsImpl();
-		params.setPosition(toImpl(cursor));
-		params.setTextDocument(doc.getId());
-		return server.getTextDocumentService().completion(params).get();
-	}
-
-	private PositionImpl toImpl(Position pos) {
-		if (pos instanceof PositionImpl) {
-			return (PositionImpl) pos;
-		} else {
-			PositionImpl imp = new PositionImpl();
-			imp.setCharacter(pos.getCharacter());
-			imp.setLine(pos.getLine());
-			return imp;
-		}
-	}
-
-	private CompletionItem resolveCompletionItem(CompletionItem unresolved) {
-		try {
-			return server.getTextDocumentService().resolveCompletionItem(unresolved).get();
-		} catch (Exception e) {
-			throw new RuntimeException(e);
-		}
-	}
-	
-	public List<CompletionItem> resolveCompletions(CompletionList completions) {
-		return completions.getItems().stream()
-		.map(this::resolveCompletionItem)
-		.collect(Collectors.toList());
-	}
-
-	public Editor newEditor(String contents) throws Exception {
-		return new Editor(this, contents);
-	}
-
-	public synchronized TextDocumentInfo createWorkingCopy(String contents) throws Exception {
-		TextDocumentItemImpl doc = new TextDocumentItemImpl();
-		doc.setLanguageId(getLanguageId());
-		doc.setText(contents);
-		doc.setUri(createTempUri());
-		doc.setVersion(getFirstVersion());
-		TextDocumentInfo docinfo = new TextDocumentInfo(doc);
-		documents.put(docinfo.getUri(), docinfo);
-		return docinfo;
-	}
-
-	protected int getFirstVersion() {
-		return 1;
-	}
-
-	protected String createTempUri() throws Exception {
-		return File.createTempFile("workingcopy", getFileExtension()).toURI().toString();
-	}
-
-}

vscode-extensions/vscode-manifest-yaml/src/test/java/org/springframework/ide/vscode/testharness/TextDocumentInfo.java

@@ -1,130 +0,0 @@
-package org.springframework.ide.vscode.testharness;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import io.typefox.lsapi.Position;
-import io.typefox.lsapi.PositionImpl;
-import io.typefox.lsapi.Range;
-import io.typefox.lsapi.TextDocumentIdentifierImpl;
-import io.typefox.lsapi.TextDocumentItemImpl;
-
-public class TextDocumentInfo {
-
-	Pattern NEWLINE = Pattern.compile("\\r|\\n|\\r\\n|\\n\\r");
-	
-	private final TextDocumentItemImpl document;
-	
-	private int[] _lineStarts;
-
-	public TextDocumentInfo(TextDocumentItemImpl document) {
-		this.document = document;
-	}
-
-	public String getLanguageId() {
-		return getDocument().getLanguageId();
-	}
-
-	public int getVersion() {
-		return getDocument().getVersion();
-	}
-
-	public String getText() {
-		return getDocument().getText();
-	}
-
-	public String getUri() {
-		return getDocument().getUri();
-	}
-
-	public TextDocumentItemImpl getDocument() {
-		return document;
-	}
-
-	public String getText(Range rng) {
-		int start = toOffset(rng.getStart());
-		int end = toOffset(rng.getEnd());
-		return getText().substring(start, end);
-	}
-
-	public int toOffset(Position p) {
-		int startOfLine = startOfLine(p.getLine());
-		return startOfLine+p.getCharacter();
-	}
-
-	private int startOfLine(int line) {
-		return lineStarts()[line];
-	}
-
-	private int[] lineStarts() {
-		if (_lineStarts==null) {
-			_lineStarts = parseLines();
-		}
-		return _lineStarts;
-	}
-
-	private int[] parseLines() {
-		List<Integer> lineStarts = new ArrayList<>();
-		lineStarts.add(0);
-		Matcher matcher = NEWLINE.matcher(getText());
-		int pos = 0;
-		while (matcher.find(pos)) {
-			lineStarts.add(pos = matcher.end());
-		}
-		int[] array = new int[lineStarts.size()];
-		for (int i = 0; i < array.length; i++) {
-			array[i] = lineStarts.get(i);
-		}
-		return array;
-	}
-
-	/**
-	 * Find and return the (first) position of a given text snippet in the
-	 * document.
-	 * 
-	 * @return The position, or null if the snippet can't be found.
-	 */
-	public Position positionOf(String snippet) {
-		int offset = getText().indexOf(snippet);
-		if (offset>=0) {
-			return toPosition(offset);
-		}
-		return null;
-	}
-
-	public Position toPosition(int offset) {
-		int line = lineNumber(offset);
-		int startOfLine = startOfLine(line);
-		int column = offset - startOfLine;
-		PositionImpl pos = new PositionImpl();
-		pos.setCharacter(column);
-		pos.setLine(line);
-		return pos;
-	}
-
-	/**
-	 * Determine the line-number a given offset (i.e. what line is the offset inside of?)
-	 */
-	private int lineNumber(int offset) {
-		int[] lineStarts = lineStarts();
-		// TODO Could use binary search which is faster
-		int lineNumber = 0;
-		for (int i = 0; i < lineStarts.length; i++) {
-			if (lineStarts[i]<=offset) {
-				lineNumber = i;
-			} else {
-				return lineNumber;
-			}
-		}
-		return lineNumber;
-	}
-
-	public TextDocumentIdentifierImpl getId() {
-		TextDocumentIdentifierImpl id = new TextDocumentIdentifierImpl();
-		id.setUri(getUri());
-		return id;
-	}
-	
-}

vscode-extensions/vscode-manifest-yaml/src/test/java/org/springframework/ide/vscode/yaml/ApplicationYamlEditorTest.java

@@ -1,52 +0,0 @@
-package org.springframework.ide.vscode.yaml;
-
-import org.junit.Test;
-import org.springframework.ide.vscode.testharness.Editor;
-import org.springframework.ide.vscode.testharness.LanguageServerHarness;
-import org.springframework.ide.vscode.yaml.YamlLanguageServer;
-
-/**
- * This class is a placeholder where we will attempt to copy and port
- * as many tests a possible from 
- * org.springframework.ide.eclipse.boot.properties.editor.test.YamlEditorTests
- * 
- * @author Kris De Volder
- */
-public class ApplicationYamlEditorTest {
-		
-	@Test public void testReconcileCatchesParseError() throws Exception {
-		LanguageServerHarness harness = new LanguageServerHarness(YamlLanguageServer::new);
-		harness.intialize(null);
-		
-		Editor editor = harness.newEditor(
-				"somemap: val\n"+
-				"- sequence"
-		);
-		editor.assertProblems(
-				"-|expected <block end>"
-		);
-	}
-	
-	@Test public void linterRunsOnDocumentOpenAndChange() throws Exception {
-		LanguageServerHarness harness = new LanguageServerHarness(YamlLanguageServer::new);
-		harness.intialize(null);
-
-		Editor editor = harness.newEditor(
-				"somemap: val\n"+
-				"- sequence"
-		);
-
-		editor.assertProblems(
-				"-|expected <block end>"
-		);
-		
-		editor.setText(
-				"- sequence\n" +
-				"zomemap: val"
-		);
-
-		editor.assertProblems(
-				"z|expected <block end>"
-		);
-	}
-}

vscode-extensions/vscode-manifest-yaml/src/test/java/org/springframework/ide/vscode/yaml/ManifestYamlEditorTest.java

@@ -0,0 +1,383 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.springframework.ide.vscode.yaml;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.springframework.ide.vscode.cloudfoundry.manifest.editor.ManifestYamlLanguageServer;
+import org.springframework.ide.vscode.testharness.Editor;
+import org.springframework.ide.vscode.testharness.LanguageServerHarness;
+
+public class ManifestYamlEditorTest {
+
+	LanguageServerHarness harness;
+	
+	@Before public void setup() throws Exception {
+		harness = new LanguageServerHarness(ManifestYamlLanguageServer::new);
+		harness.intialize(null);
+	}
+
+	@Test public void testReconcileCatchesParseError() throws Exception {
+		
+		Editor editor = harness.newEditor(
+				"somemap: val\n"+
+				"- sequence"
+		);
+		editor.assertProblems(
+				"-|expected <block end>"
+		);
+	}
+	
+	@Test public void reconcileRunsOnDocumentOpenAndChange() throws Exception {
+		LanguageServerHarness harness = new LanguageServerHarness(ManifestYamlLanguageServer::new);
+		harness.intialize(null);
+
+		Editor editor = harness.newEditor(
+				"somemap: val\n"+
+				"- sequence"
+		);
+
+		editor.assertProblems(
+				"-|expected <block end>"
+		);
+		
+		editor.setText(
+				"- sequence\n" +
+				"zomemap: val"
+		);
+
+		editor.assertProblems(
+				"z|expected <block end>"
+		);
+	}
+
+	@Test
+	public void reconcileMisSpelledPropertyNames() throws Exception {
+		Editor editor;
+
+		editor = harness.newEditor(
+				"memory: 1G\n" +
+				"aplications:\n" +
+				"  - buildpack: zbuildpack\n" +
+				"    domain: zdomain\n" +
+				"    name: foo"
+		);
+		editor.assertProblems("aplications|Unknown property");
+
+		//mispelled or not allowed at toplevel
+		editor = harness.newEditor(
+				"name: foo\n" +
+				"buildpeck: yahah\n" +
+				"memory: 1G\n" +
+				"memori: 1G\n"
+		);
+		editor.assertProblems(
+				"name|Unknown property",
+				"buildpeck|Unknown property",
+				"memori|Unknown property"
+		);
+
+		//mispelled or not allowed as nested
+		editor = harness.newEditor(
+				"applications:\n" +
+				"- name: fine\n" +
+				"  buildpeck: yahah\n" +
+				"  memory: 1G\n" +
+				"  memori: 1G\n" +
+				"  applications: bad\n"
+		);
+		editor.assertProblems(
+				"buildpeck|Unknown property",
+				"memori|Unknown property",
+				"applications|Unknown property"
+		);
+	}
+
+	@Test
+	public void reconcileStructuralProblems() throws Exception {
+		Editor editor;
+
+		//forgot the 'applications:' heading
+		editor = harness.newEditor(
+				"- name: foo"
+		);
+		editor.assertProblems(
+				"- name: foo|Expecting a 'Map' but found a 'Sequence'"
+		);
+
+		//forgot to make the '-' after applications
+		editor = harness.newEditor(
+				"applications:\n" +
+				"  name: foo"
+		);
+		editor.assertProblems(
+				"name: foo|Expecting a 'Sequence' but found a 'Map'"
+		);
+
+		//Using a 'composite' element where a scalar type is expected
+		editor = harness.newEditor(
+				"memory:\n"+
+				"- bad sequence\n" +
+				"buildpack:\n" +
+				"  bad: map\n"
+		);
+		editor.assertProblems(
+				"- bad sequence|Expecting a 'Memory' but found a 'Sequence'",
+				"bad: map|Expecting a 'Buildpack' but found a 'Map'"
+		);
+	}
+
+	@Test
+	public void reconcileSimpleTypes() throws Exception {
+		Editor editor;
+
+		//check for 'format' errors:
+		editor = harness.newEditor(
+				"applications:\n" +
+				"- name: foo\n" +
+				"  instances: not a number\n" +
+				"  no-route: notBool\n"+
+				"  memory: 1024\n" +
+				"  disk_quota: 2048\n"
+		);
+		editor.assertProblems(
+				"not a number|Positive Integer",
+				"notBool|boolean",
+				"1024|Memory",
+				"2048|Memory"
+		);
+
+		//check for 'range' errors:
+		editor = harness.newEditor(
+				"applications:\n" +
+				"- name: foo\n" +
+				"  instances: -3\n" +
+				"  memory: -1024M\n" +
+				"  disk_quota: -2048M\n"
+		);
+		editor.assertProblems(
+				"-3|Positive Integer",
+				"-1024M|Memory",
+				"-2048M|Memory"
+		);
+
+		//check that correct values are indeed accepted
+		editor = harness.newEditor(
+				"applications:\n" +
+				"- name: foo\n" +
+				"  instances: 2\n" +
+				"  no-route: true\n"+
+				"  memory: 1024M\n" +
+				"  disk_quota: 2048MB\n"
+		);
+		editor.assertProblems(/*none*/);
+
+		//check that correct values are indeed accepted
+		editor = harness.newEditor(
+				"applications:\n" +
+				"- name: foo\n" +
+				"  instances: 2\n" +
+				"  no-route: false\n" +
+				"  memory: 1024m\n" +
+				"  disk_quota: 2048mb\n"
+		);
+		editor.assertProblems(/*none*/);
+
+		editor = harness.newEditor(
+				"applications:\n" +
+				"- name: foo\n" +
+				"  instances: 2\n" +
+				"  memory: 1G\n" +
+				"  disk_quota: 2g\n"
+		);
+		editor.assertProblems(/*none*/);
+	}
+
+	@Test @Ignore
+	public void toplevelCompletions() throws Exception {
+		Editor editor;
+		editor = harness.newEditor("<*>");
+		editor.assertCompletions(
+				"applications:\n"+
+				"  - <*>",
+				// ---------------
+				"buildpack: <*>",
+				// ---------------
+				"command: <*>",
+				// ---------------
+				"disk_quota: <*>",
+				// ---------------
+				"domain: <*>",
+				// ---------------
+				"domains:\n"+
+				"  - <*>",
+				// ---------------
+				"env:\n"+
+				"  <*>",
+				// ---------------
+//				"host: <*>",
+				// ---------------
+//				"hosts: \n"+
+//				"  - <*>",
+				// ---------------
+				"inherit: <*>",
+				// ---------------
+				"instances: <*>",
+				// ---------------
+				"memory: <*>",
+				// ---------------
+//				"name: <*>",
+				// ---------------
+				"no-hostname: <*>",
+				// ---------------
+				"no-route: <*>",
+				// ---------------
+				"path: <*>",
+				// ---------------
+				"random-route: <*>",
+				// ---------------
+				"services:\n"+
+				"  - <*>",
+				// ---------------
+				"stack: <*>",
+				// ---------------
+				"timeout: <*>"
+		);
+
+		editor = harness.newEditor("ranro<*>");
+		editor.assertCompletions(
+				"random-route: <*>"
+		);
+	}
+
+	@Test @Ignore
+	public void nestedCompletions() throws Exception {
+		Editor editor;
+		editor = harness.newEditor(
+				"applications:\n" +
+				"  - <*>"
+		);
+		editor.assertCompletions(
+				// ---------------
+				"applications:\n" +
+				"  - buildpack: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - command: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - disk_quota: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - domain: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - domains:\n"+
+				"      - <*>",
+				// ---------------
+				"applications:\n" +
+				"  - env:\n"+
+				"      <*>",
+				// ---------------
+				"applications:\n" +
+				"  - host: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - hosts:\n"+
+				"      - <*>",
+				// ---------------
+				"applications:\n" +
+				"  - instances: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - memory: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - name: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - no-hostname: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - no-route: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - path: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - random-route: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - services:\n"+
+				"      - <*>",
+				// ---------------
+				"applications:\n" +
+				"  - stack: <*>",
+				// ---------------
+				"applications:\n" +
+				"  - timeout: <*>"
+		);
+	}
+
+	@Test @Ignore
+	public void valueCompletions() throws Exception {
+		assertCompletions("disk_quota: <*>",
+				"disk_quota: 1024M<*>",
+				"disk_quota: 256M<*>",
+				"disk_quota: 512M<*>"
+		);
+		assertCompletions("memory: <*>",
+				"memory: 1024M<*>",
+				"memory: 256M<*>",
+				"memory: 512M<*>"
+		);
+		assertCompletions("no-hostname: <*>",
+				"no-hostname: false<*>",
+				"no-hostname: true<*>"
+		);
+		assertCompletions("no-route: <*>",
+				"no-route: false<*>",
+				"no-route: true<*>"
+		);
+		assertCompletions("random-route: <*>",
+				"random-route: false<*>",
+				"random-route: true<*>"
+		);
+	}
+
+	@Test @Ignore
+	public void hoverInfos() throws Exception {
+		Editor editor = harness.newEditor(
+				"memory: 1G\n" +
+				"applications:\n" +
+				"  - buildpack: zbuildpack\n" +
+				"    domain: zdomain\n" +
+				"    name: foo"
+		);
+		editor.assertIsHoverRegion("memory");
+		editor.assertIsHoverRegion("applications");
+		editor.assertIsHoverRegion("buildpack");
+		editor.assertIsHoverRegion("domain");
+		editor.assertIsHoverRegion("name");
+
+		editor.assertHoverContains("memory", "Use the <code>memory</code> attribute to specify the memory limit");
+		editor.assertHoverContains("1G", "Use the <code>memory</code> attribute to specify the memory limit");
+		editor.assertHoverContains("buildpack", "use the <code>buildpack</code> attribute to specify its URL or name");
+	}
+
+	//////////////////////////////////////////////////////////////////////////////
+
+	private void assertCompletions(String textBefore, String... textAfter) throws Exception {
+		Editor editor = harness.newEditor(textBefore);
+		editor.assertCompletions(textAfter);
+	}
+}

vscode-extensions/vscode-manifest-yaml/src/test/java/org/springframework/ide/vscode/yaml/ManifestYamlLanguageServerTest.java

@@ -8,24 +8,24 @@ import java.nio.file.Paths;
 import java.util.List;
 
 import org.junit.Test;
+import org.springframework.ide.vscode.cloudfoundry.manifest.editor.ManifestYamlLanguageServer;
 import org.springframework.ide.vscode.testharness.LanguageServerHarness;
 import org.springframework.ide.vscode.testharness.TextDocumentInfo;
-import org.springframework.ide.vscode.yaml.YamlLanguageServer;
 
 import io.typefox.lsapi.CompletionItem;
 import io.typefox.lsapi.CompletionList;
 import io.typefox.lsapi.InitializeResult;
 import io.typefox.lsapi.ServerCapabilities;
 
-public class YamlLanguageServerTest {
+public class ManifestYamlLanguageServerTest {
 
 	public static File getTestResource(String name) throws URISyntaxException {
-		return Paths.get(YamlLanguageServerTest.class.getResource(name).toURI()).toFile();
+		return Paths.get(ManifestYamlLanguageServerTest.class.getResource(name).toURI()).toFile();
 	}
 
 	@Test
 	public void createAndInitializeServerWithWorkspace() throws Exception {
-		LanguageServerHarness harness = new LanguageServerHarness(YamlLanguageServer::new);
+		LanguageServerHarness harness = new LanguageServerHarness(ManifestYamlLanguageServer::new);
 		File workspaceRoot = getTestResource("/workspace/");
 		assertExpectedInitResult(harness.intialize(workspaceRoot));
 	}
@@ -33,13 +33,13 @@ public class YamlLanguageServerTest {
 	@Test
 	public void createAndInitializeServerWithoutWorkspace() throws Exception {
 		File workspaceRoot = null;
-		LanguageServerHarness harness = new LanguageServerHarness(YamlLanguageServer::new);
+		LanguageServerHarness harness = new LanguageServerHarness(ManifestYamlLanguageServer::new);
 		assertExpectedInitResult(harness.intialize(workspaceRoot));
 	}
 	
 	
 	@Test public void completions() throws Exception {
-		LanguageServerHarness harness = new LanguageServerHarness(YamlLanguageServer::new);
+		LanguageServerHarness harness = new LanguageServerHarness(ManifestYamlLanguageServer::new);
 		
 		File workspaceRoot = getTestResource("/workspace/");
 		assertExpectedInitResult(harness.intialize(workspaceRoot));

vscode-extensions/vscode-manifest-yaml/src/test/java/org/springframework/ide/vscode/yaml/ManifestYmlSchemaTest.java

@@ -0,0 +1,144 @@
+package org.springframework.ide.vscode.yaml;
+/*******************************************************************************
+ * Copyright (c) 2015, 2016 Pivotal, Inc.
+ * 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:
+ *     Pivotal, Inc. - initial API and implementation
+ *******************************************************************************/
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+import org.springframework.ide.vscode.cloudfoundry.manifest.editor.ManifestYmlSchema;
+import org.springframework.ide.vscode.util.StringUtil;
+import org.springframework.ide.vscode.yaml.schema.YTypeFactory.YBeanType;
+import org.springframework.ide.vscode.yaml.schema.YTypeFactory.YSeqType;
+import org.springframework.ide.vscode.yaml.schema.YTypedProperty;
+import org.springframework.ide.vscode.yaml.util.DescriptionProviders;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSet.Builder;
+
+/**
+ * @author Kris De Volder
+ */
+public class ManifestYmlSchemaTest {
+
+	private static final String[] NESTED_PROP_NAMES = {
+//			"applications",
+			"buildpack",
+			"command",
+			"disk_quota",
+			"domain",
+			"domains",
+			"env",
+			"host",
+			"hosts",
+//			"inherit",
+			"instances",
+			"memory",
+			"name",
+			"no-hostname",
+			"no-route",
+			"path",
+			"random-route",
+			"services",
+			"stack",
+			"timeout"
+	};
+
+	private static final String[] TOPLEVEL_PROP_NAMES = {
+			"applications",
+			"buildpack",
+			"command",
+			"disk_quota",
+			"domain",
+			"domains",
+			"env",
+//			"host",
+//			"hosts",
+			"inherit",
+			"instances",
+			"memory",
+//			"name",
+			"no-hostname",
+			"no-route",
+			"path",
+			"random-route",
+			"services",
+			"stack",
+			"timeout"
+	};
+
+	ManifestYmlSchema schema = new ManifestYmlSchema(null);
+
+	@Test
+	public void toplevelProperties() throws Exception {
+		assertPropNames(schema.getTopLevelType().getProperties(), TOPLEVEL_PROP_NAMES);
+		assertPropNames(schema.getTopLevelType().getPropertiesMap(), TOPLEVEL_PROP_NAMES);
+	}
+
+	@Test
+	public void nestedProperties() throws Exception {
+		assertPropNames(getNestedProps(), NESTED_PROP_NAMES);
+	}
+
+	@Test
+	public void toplevelPropertiesHaveDescriptions() {
+		for (YTypedProperty p : schema.getTopLevelType().getProperties()) {
+			if (!p.getName().equals("applications")) {
+				assertHasRealDescription(p);
+			}
+		}
+	}
+
+	@Test
+	public void nestedPropertiesHaveDescriptions() {
+		for (YTypedProperty p : getNestedProps()) {
+			assertHasRealDescription(p);
+		}
+	}
+
+	//////////////////////////////////////////////////////////////////////////////
+
+	private void assertHasRealDescription(YTypedProperty p) {
+		String noDescriptionText = DescriptionProviders.NO_DESCRIPTION.get().toText();
+		String actual = p.getDescription().toText();
+		String msg = "Description missing for '"+p.getName()+"'";
+		assertTrue(msg, StringUtil.hasText(actual));
+		assertFalse(msg, noDescriptionText.equals(actual));
+	}
+
+	private List<YTypedProperty> getNestedProps() {
+		YSeqType applications = (YSeqType) schema.getTopLevelType().getPropertiesMap().get("applications").getType();
+		YBeanType application = (YBeanType) applications.getDomainType();
+		return application.getProperties();
+	}
+
+	private void assertPropNames(List<YTypedProperty> properties, String... expectedNames) {
+		assertEquals(ImmutableSet.copyOf(expectedNames), getNames(properties));
+	}
+
+	private void assertPropNames(Map<String, YTypedProperty> propertiesMap, String[] toplevelPropNames) {
+		assertEquals(ImmutableSet.copyOf(toplevelPropNames), ImmutableSet.copyOf(propertiesMap.keySet()));
+	}
+
+	private ImmutableSet<String> getNames(Iterable<YTypedProperty> properties) {
+		Builder<String> builder = ImmutableSet.builder();
+		for (YTypedProperty p : properties) {
+			builder.add(p.getName());
+		}
+		return builder.build();
+	}
+
+}

vscode-extensions/vscode-manifest-yaml/test/examples/manifest.yml

@@ -1,2 +1,5 @@
-foo: bar
-- asss
+applications:
+- name: foo
+  foo: bar
+  builpack: java
+