Merge lp:~zeller-benjamin/ubuntu-sdk-ide/snapcraft-step2 into lp:ubuntu-sdk-ide

[Benjamin Zeller]

Snapcraft support plan step 2
-> support snapcraft.yaml as project format
-> build snap files directly from the IDE
-> basic template
-> support building in containers

Snapcraft support plan step 2
-> support snapcraft.yaml as project format
-> build snap files directly from the IDE
-> basic template
-> support building in containers

[lp:~zeller-benjamin/ubuntu-sdk-ide/snapcraft-step2]

165. By Benjamin Zeller on 2016-10-18

Add missing yaml library

[ubuntu-sdk-build-bot (ubuntu-sdk-build-bot)]

PASSED: Continuous integration, rev:165
https://jenkins.ubuntu.com/ubuntu-sdk/job/qtcreator-ide-ci-amd64/355/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/7110/console

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/ubuntu-sdk/job/qtcreator-ide-ci-amd64/355/rebuild

review: Approve (continuous-integration)

[Zoltan Balogh (bzoltan)]

Let's see

review: Approve

[ubuntu-sdk-build-bot (ubuntu-sdk-build-bot)]

PASSED: Continuous integration, rev:165
https://jenkins.ubuntu.com/ubuntu-sdk/job/qtcreator-ide-ci-amd64/357/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/7112/console

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/ubuntu-sdk/job/qtcreator-ide-ci-amd64/357/rebuild

review: Approve (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-09-22 16:11:03 +0000
+++ CMakeLists.txt	2016-10-18 07:57:32 +0000
@@ -64,7 +64,11 @@
                   COMMAND ${CMAKE_SOURCE_DIR}/get_bzr_source.py -d "${EXT_SOURCE_DIR}/qtcreator/src/plugins/ubuntu" lp:qtcreator-plugin-ubuntu
                   WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
 
-add_custom_target(sources DEPENDS QtSource LibDusSource MaliitSource fcitx-qtSource AppmenuSource QtCreatorSource)
+add_custom_target(YamlCppSource
+                  ${CMAKE_SOURCE_DIR}/get_package_source.py yaml-cpp
+                  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+
+add_custom_target(sources DEPENDS QtSource LibDusSource MaliitSource fcitx-qtSource AppmenuSource QtCreatorSource YamlCppSource)
 
 add_custom_command(TARGET sources
                    PRE_BUILD
@@ -123,6 +127,29 @@
   INSTALL_COMMAND   sh -c "LD_LIBRARY_PATH=${QT_INSTALL_DIR}/lib make install"
 )
 
+ConcatStrings (LIBYAML_BUILD_SCRIPT
+  "${CMAKE_COMMAND} "
+  "-DCMAKE_INSTALL_PREFIX=${QT_INSTALL_DIR} "
+  "-DCMAKE_PREFIX_PATH=${QT_INSTALL_DIR} "
+  "-DCMAKE_BUILD_TYPE=DEBUG" #${CMAKE_BUILD_TYPE_STRING} "
+  "-DCMAKE_INSTALL_LIBDIR=lib ${EXT_SOURCE_DIR}/yaml-cpp "
+  "-DCMAKE_C_FLAGS=-fPIC "
+  "-DCMAKE_CXX_FLAGS=-fPIC "
+)
+
+SET (LIBYAML_PREFIX "${CMAKE_BINARY_DIR}/yaml-cpp")
+ExternalProject_Add(libyaml-cpp
+  DEPENDS ${QT_VERSION}
+  PREFIX      "${LIBYAML_PREFIX}"
+  SOURCE_DIR  "${EXT_SOURCE_DIR}/yaml-cpp"
+  BINARY_DIR  "${LIBYAML_PREFIX}/build"
+  INSTALL_DIR "${QT_INSTALL_DIR}"
+  DOWNLOAD_COMMAND  sh -c "exit 0"
+  CONFIGURE_COMMAND sh -c "${LIBYAML_BUILD_SCRIPT}"
+  BUILD_COMMAND     sh -c "LD_LIBRARY_PATH=${QT_INSTALL_DIR}/lib make  ${GENERATED_MAKE_FLAGS}"
+  INSTALL_COMMAND   sh -c "LD_LIBRARY_PATH=${QT_INSTALL_DIR}/lib make install"
+)
+
 SET (MALIITPLUGIN_PREFIX "${CMAKE_BINARY_DIR}/maliit-plugin-qt-build")
 ExternalProject_Add(maliit-plugin
   DEPENDS     ${QT_VERSION}
@@ -172,7 +199,7 @@
 
 SET (QTCREATOR_PREFIX "${CMAKE_BINARY_DIR}/qtcreator-build")
 ExternalProject_Add(qtcreator_3.5.0
-  DEPENDS appmenu-qt5 fcitx-qt5 maliit-plugin
+  DEPENDS appmenu-qt5 fcitx-qt5 maliit-plugin libyaml-cpp
   PREFIX      "${QTCREATOR_PREFIX}"
   SOURCE_DIR  "${EXT_SOURCE_DIR}/qtcreator"
   BINARY_DIR  "${QTCREATOR_PREFIX}/build"
 
=== modified file 'dist/qtcreator/src/plugins/ubuntu/UbuntuPlugin.pro'
--- dist/qtcreator/src/plugins/ubuntu/UbuntuPlugin.pro	2016-09-22 16:11:03 +0000
+++ dist/qtcreator/src/plugins/ubuntu/UbuntuPlugin.pro	2016-10-18 07:57:32 +0000
@@ -220,6 +220,8 @@
     src/ubuntu/device/remote/ubuntudirectuploadstep.h \
     src/ubuntu/device/remote/ubuntudeploystepfactory.h
 
+include(src/ubuntu/snap/snap.pri)
+
 
 FORMS += \
     src/ubuntu/device/remote/ubunturemoterunconfigurationwidget.ui \
 
=== removed file 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName.pro'
--- dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName.pro	2016-09-22 16:11:03 +0000
+++ dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName.pro	1970-01-01 00:00:00 +0000
@@ -1,32 +0,0 @@
-# This is the basic qmake template for the Ubuntu-SDK
-# it handles creation and installation of the manifest
-# file and takes care of subprojects
-TEMPLATE = subdirs
-
-SUBDIRS += %{ProjectNameL}
-
-# enables/disabled the extra targets to build a snapcraft package
-# also tells the IDE this is a snapcraft project
-CONFIG += snapcraft
-
-snapcraft {
-
-    SNAPCRAFT_FILE=snapcraft.yaml
-
-    #the Ubuntu SDK IDE uses the snap target to create the package
-    snappy.target = snap
-    snappy.commands = cd $$OUT_PWD
-    snappy.commands += && rm -rf \'$$OUT_PWD/snap-deploy\'
-    snappy.commands += && make INSTALL_ROOT=$$OUT_PWD/snap-deploy install
-    snappy.commands += && cd $$OUT_PWD/snap-deploy
-    snappy.commands += && snapcraft
-
-    OTHER_FILES+=$$SNAPCRAFT_FILE
-    QMAKE_EXTRA_TARGETS += snappy
-
-    packaging.files = $$SNAPCRAFT_FILE
-    packaging.path  = /
-
-    INSTALLS+=packaging
-}
-
 
=== removed file 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.desktop'
--- dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.desktop	2016-09-22 16:11:03 +0000
+++ dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.desktop	1970-01-01 00:00:00 +0000
@@ -1,9 +0,0 @@
-[Desktop Entry]
-Version=1.0
-Name=%{ProjectNameL}
-Exec=%{ProjectNameL}
-TryExec=%{ProjectNameL}
-Icon=${SNAP}/meta/gui/%{ProjectNameL}.png
-Terminal=false
-Type=Application
-X-Ubuntu-Touch=true
 
=== removed file 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.png'
 Binary files dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.png	2016-09-22 16:11:03 +0000 and dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.png	1970-01-01 00:00:00 +0000 differ
=== modified file 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.pro'
--- dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.pro	2016-09-22 16:11:03 +0000
+++ dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.pro	2016-10-18 07:57:32 +0000
@@ -16,33 +16,16 @@
 
 CONF_FILES +=  %{ProjectNameL}.png
 
-AP_TEST_FILES += tests/autopilot/run \
-                 $$files(tests/*.py,true)
-
 #show all the files in QtCreator
 OTHER_FILES += $${CONF_FILES} \
                $${QML_FILES} \
-               $${AP_TEST_FILES} \
                %{ProjectNameL}.desktop \
                %{ProjectNameL}.wrapper
 
 snapcraft {
-    #specify where the config files are installed to
-    config_files.path = /setup/gui
-    config_files.files += $${CONF_FILES}
-    INSTALLS+=config_files
-
-    #install the desktop file
-    desktop_file.path = /setup/gui
-    desktop_file.files = $$PWD/%{ProjectNameL}.desktop
-    desktop_file.CONFIG += no_check_exist
-    INSTALLS+=desktop_file
-
-    # Default rules for deployment.
-
     wrapper.files = %{ProjectNameL}.wrapper
-    wrapper.path  = /deploy/bin
+    wrapper.path  = /bin
 
-    target.path = /deploy/bin
+    target.path = /bin
     INSTALLS+=target wrapper
 }
 
=== added directory 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup'
=== added directory 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup/gui'
=== added file 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup/gui/appName.desktop'
--- dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup/gui/appName.desktop	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup/gui/appName.desktop	2016-10-18 07:57:32 +0000
@@ -0,0 +1,9 @@
+[Desktop Entry]
+Version=1.0
+Name=%{ProjectNameL}
+Exec=%{ProjectNameL}
+TryExec=%{ProjectNameL}
+Icon=${SNAP}/meta/gui/%{ProjectNameL}.png
+Terminal=false
+Type=Application
+X-Ubuntu-Touch=true
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup/gui/appName.png'
 Binary files dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup/gui/appName.png	1970-01-01 00:00:00 +0000 and dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup/gui/appName.png	2016-10-18 07:57:32 +0000 differ
=== modified file 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/snapcraft.yaml'
--- dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/snapcraft.yaml	2016-09-22 16:11:03 +0000
+++ dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/snapcraft.yaml	2016-10-18 07:57:32 +0000
@@ -11,13 +11,19 @@
 
 parts:
   %{ProjectNameL}:
-    plugin: dump
-    source: deploy/
+    plugin: qmake
+    source: %{ProjectNameL}/
+    qt-version: qt5
+    options: ["CONFIG+=snapcraft"]
+    project-files: [%{ProjectNameL}]
+    build-packages:
+      - build-essential
+      - qtbase5-dev
+      - qt5-qmake
     stage-packages:
       - ubuntu-sdk-libs
       - qtubuntu-desktop
       - qtmir-desktop
       - mir-graphics-drivers-desktop
-
-
+    after: [qt5conf]
 
 
=== modified file 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/wizard.json'
--- dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/wizard.json	2016-09-22 16:11:03 +0000
+++ dist/qtcreator/src/plugins/ubuntu/share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/wizard.json	2016-10-18 07:57:32 +0000
@@ -1,13 +1,13 @@
 {
     "version": 1,
-    "supportedProjectTypes": [ "Qt4ProjectManager.Qt4Project" ],
+    "supportedProjectTypes": [ "SnapcraftProjectManager.SnapcraftProject" ],
     "id": "A.QtQuick Snappy Application",
     "category": "B.Snapcraft",
     "trDescription": "Creates a experimental C++ Ubuntu snappy application project with a sample UI containing a Label and a Button.",
     "trDisplayName": "QtQuick App with QML Ubuntu UI",
     "trDisplayCategory": "Snapcraft",
     "icon": "../share/ubuntu.png",
-    "enabled": "%{JS: [ %{Plugins} ].indexOf('QmakeProjectManager') >= 0}",
+    "enabled": "%{JS: [ %{Plugins} ].indexOf('Ubuntu') >= 0}",
 
     "options":
     [
@@ -62,15 +62,10 @@
             "data":
             [
                 {
-                    "source": "appName.pro",
-                    "target": "%{ProjectFile}",
+                    "source": "snapcraft.yaml",
                     "openAsProject": true
                 },
                 {
-                    "source": "snapcraft.yaml",
-                    "openInEditor": true
-                },
-                {
                     "source": "appName/main.cpp",
                     "target": "%{ProjectDirectory}/%{ProjectNameL}/%{CppFileName}",
                     "openInEditor": true
@@ -81,12 +76,12 @@
                     "openInEditor": true
                 },
                 {
-                    "source": "appName/appName.desktop",
-                    "target": "%{ProjectDirectory}/%{ProjectNameL}/%{ProjectNameL}.desktop"
+                    "source": "setup/gui/appName.desktop",
+                    "target": "%{ProjectDirectory}/setup/gui/%{ProjectNameL}.desktop"
                 },
                 {
-                    "source": "appName/appName.png",
-                    "target": "%{ProjectDirectory}/%{ProjectNameL}/%{ProjectNameL}.png"
+                    "source": "setup/gui/appName.png",
+                    "target": "%{ProjectDirectory}/setup/gui/%{ProjectNameL}.png"
                 },
                 {
                     "source": "appName/appName.pro",
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/share/qtcreator/ubuntu/scripts/run_snapcraft.py'
--- dist/qtcreator/src/plugins/ubuntu/share/qtcreator/ubuntu/scripts/run_snapcraft.py	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/share/qtcreator/ubuntu/scripts/run_snapcraft.py	2016-10-18 07:57:32 +0000
@@ -0,0 +1,29 @@
+#!/usr/bin/python3
+
+import os
+import sys
+import shutil
+import subprocess
+from optparse import OptionParser
+
+parser = OptionParser(usage="usage: %prog [options] lp:branch")
+parser.add_option(
+    "-s", "--snapcraft", dest="snapcraft")
+options, args = parser.parse_args()
+
+if options.snapcraft is None:
+    options.snapcraft = shutil.which("snapcraft")
+
+if options.snapcraft is None:
+    parser.error("Snapcraft not found.")
+
+if not os.path.isfile(options.snapcraft) or not os.access(options.snapcraft, os.X_OK):
+    parser.error("-s must specify a executable file.")
+
+print("Using snapcraft from :"+options.snapcraft)
+
+ret = subprocess.call([options.snapcraft, "clean"])
+if ret != 0:
+    sys.exit(ret)
+
+sys.exit(subprocess.call([options.snapcraft]+args))
 
=== modified file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/UbuntuProject.mimetypes.xml'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/UbuntuProject.mimetypes.xml	2016-06-09 08:47:42 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/UbuntuProject.mimetypes.xml	2016-10-18 07:57:32 +0000
@@ -17,4 +17,9 @@
       <sub-class-of type="application/json"/>
       <glob pattern="manifest.json*"/>
   </mime-type>
+  <mime-type type="application/x-snapcraft">
+      <comment>Snapcraft project file</comment>
+      <sub-class-of type="application/x-yaml"/>
+      <glob pattern="snapcraft.yaml"/>
+  </mime-type>
 </mime-info>
 
=== added directory 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project'
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfiguration.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfiguration.cpp	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfiguration.cpp	2016-10-18 07:57:32 +0000
@@ -0,0 +1,41 @@
+#include "snapcraftbuildconfiguration.h"
+
+#include <ubuntu/ubuntuconstants.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+SnapcraftBuildConfiguration::SnapcraftBuildConfiguration(ProjectExplorer::Target *target)
+    : ProjectExplorer::BuildConfiguration(target, Constants::SNAPCRAFT_BUILDCONFIGURATION_ID)
+{
+
+}
+
+SnapcraftBuildConfiguration::SnapcraftBuildConfiguration(ProjectExplorer::Target *target, ProjectExplorer::BuildConfiguration *source)
+    : ProjectExplorer::BuildConfiguration(target, source)
+{
+
+}
+
+bool SnapcraftBuildConfiguration::fromMap(const QVariantMap &map)
+{
+    return ProjectExplorer::BuildConfiguration::fromMap(map);
+}
+
+QVariantMap SnapcraftBuildConfiguration::toMap() const
+{
+    return ProjectExplorer::BuildConfiguration::toMap();
+}
+
+ProjectExplorer::NamedWidget *SnapcraftBuildConfiguration::createConfigWidget()
+{
+    return nullptr;
+}
+
+ProjectExplorer::BuildConfiguration::BuildType SnapcraftBuildConfiguration::buildType() const
+{
+    return ProjectExplorer::BuildConfiguration::Unknown;
+}
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfiguration.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfiguration.h	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfiguration.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,33 @@
+#ifndef UBUNTU_INTERNAL_SNAPCRAFTBUILDCONFIGURATION_H
+#define UBUNTU_INTERNAL_SNAPCRAFTBUILDCONFIGURATION_H
+
+#include <projectexplorer/buildconfiguration.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class SnapcraftBuildConfigurationFactory;
+
+class SnapcraftBuildConfiguration : public ProjectExplorer::BuildConfiguration
+{
+    Q_OBJECT
+
+public:
+    friend class SnapcraftBuildConfigurationFactory;
+    // ProjectConfiguration interface
+    virtual bool fromMap(const QVariantMap &map) override;
+    virtual QVariantMap toMap() const override;
+
+    // BuildConfiguration interface
+    virtual ProjectExplorer::NamedWidget *createConfigWidget() override;
+    virtual BuildType buildType() const override;
+
+protected:
+    SnapcraftBuildConfiguration(ProjectExplorer::Target *target);
+    SnapcraftBuildConfiguration(ProjectExplorer::Target *target, BuildConfiguration *source);
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPCRAFTBUILDCONFIGURATION_H
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.cpp	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.cpp	2016-10-18 07:57:32 +0000
@@ -0,0 +1,145 @@
+#include "snapcraftbuildconfigurationfactory.h"
+
+#include "snapcraftproject.h"
+#include "snapcraftbuildconfiguration.h"
+#include "snapcraftrsyncstep.h"
+#include "snapcraftstep.h"
+#include <ubuntu/ubuntuconstants.h>
+
+#include <projectexplorer/target.h>
+#include <projectexplorer/kit.h>
+#include <projectexplorer/projectmacroexpander.h>
+#include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/buildsteplist.h>
+
+#include <coreplugin/documentmanager.h>
+#include <utils/mimetypes/mimedatabase.h>
+#include <utils/qtcassert.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+SnapcraftBuildInfo::SnapcraftBuildInfo(const SnapcraftBuildConfigurationFactory *factory)
+    :ProjectExplorer::BuildInfo(factory)
+{
+
+}
+
+SnapcraftBuildConfigurationFactory::SnapcraftBuildConfigurationFactory()
+{
+
+}
+
+QList<ProjectExplorer::BuildInfo *> SnapcraftBuildConfigurationFactory::availableBuilds(const ProjectExplorer::Target *parent) const
+{
+    if (qobject_cast<SnapcraftProject *>(parent->project()))
+        return {};
+
+    QList<ProjectExplorer::BuildInfo *> infoList;
+    ProjectExplorer::BuildInfo *info = createBuildInfo(parent->kit(), parent->project()->projectFilePath().toString());
+    if (info)
+        infoList << info;
+
+    return infoList;
+}
+
+int SnapcraftBuildConfigurationFactory::priority(const ProjectExplorer::Target *) const
+{
+    return 0;
+}
+
+int SnapcraftBuildConfigurationFactory::priority(const ProjectExplorer::Kit *, const QString &) const
+{
+    return 0;
+}
+
+QList<ProjectExplorer::BuildInfo *> SnapcraftBuildConfigurationFactory::availableSetups(const ProjectExplorer::Kit *k, const QString &projectPath) const
+{
+    Utils::MimeDatabase db;
+
+    auto mimeType = db.mimeTypeForFile(projectPath);
+    if (!mimeType.matchesName(Constants::SNAPCRAFT_PROJECT_MIMETYPE))
+        return {};
+
+    QList<ProjectExplorer::BuildInfo *> infoList;
+    ProjectExplorer::BuildInfo *info = createBuildInfo(k, projectPath);
+    if (info)
+        infoList << info;
+
+    return infoList;
+}
+
+ProjectExplorer::BuildConfiguration *SnapcraftBuildConfigurationFactory::create(ProjectExplorer::Target *parent, const ProjectExplorer::BuildInfo *info) const
+{
+    SnapcraftBuildConfiguration *conf = new SnapcraftBuildConfiguration(parent);
+
+    conf->setDisplayName(info->displayName);
+    conf->setBuildDirectory(info->buildDirectory);
+
+    ProjectExplorer::BuildStepList *bs = conf->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
+    bs->insertStep(0, new SnapcraftRsyncStep(bs));
+    bs->insertStep(1, new SnapcraftStep(bs));
+
+    return conf;
+}
+
+bool SnapcraftBuildConfigurationFactory::canRestore(const ProjectExplorer::Target *, const QVariantMap &map) const
+{
+    return (ProjectExplorer::idFromMap(map) == Constants::SNAPCRAFT_BUILDCONFIGURATION_ID);
+}
+
+ProjectExplorer::BuildConfiguration *SnapcraftBuildConfigurationFactory::restore(ProjectExplorer::Target *parent, const QVariantMap &map)
+{
+    QTC_ASSERT(parent, return nullptr);
+    SnapcraftBuildConfiguration *conf = new SnapcraftBuildConfiguration(parent);
+    if (conf->fromMap(map))
+        return conf;
+
+    delete conf;
+    return nullptr;
+}
+
+bool SnapcraftBuildConfigurationFactory::canClone(const ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product) const
+{
+    QTC_ASSERT(parent, return false);
+    QTC_ASSERT(product, return false);
+    return (product->id() == Constants::SNAPCRAFT_BUILDCONFIGURATION_ID);
+}
+
+ProjectExplorer::BuildConfiguration *SnapcraftBuildConfigurationFactory::clone(ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product)
+{
+    QTC_ASSERT(parent, return nullptr);
+    QTC_ASSERT(product, return nullptr);
+
+    SnapcraftBuildConfiguration *conf = new SnapcraftBuildConfiguration(parent, product);
+    return conf;
+}
+
+ProjectExplorer::BuildInfo *SnapcraftBuildConfigurationFactory::createBuildInfo(const ProjectExplorer::Kit *k, const QString &projectPath) const
+{
+    SnapcraftBuildInfo *build = new SnapcraftBuildInfo(this);
+    build->buildType = ProjectExplorer::BuildConfiguration::Release;
+    build->typeName = tr("Build");
+    build->kitId = k->id();
+    build->displayName = ProjectExplorer::BuildConfiguration::buildTypeName(build->buildType);
+    build->buildDirectory = shadowBuildDirectory(k, projectPath);
+    return {build};
+}
+
+Utils::FileName SnapcraftBuildConfigurationFactory::shadowBuildDirectory(const ProjectExplorer::Kit *k, const QString &projectPath) const
+{
+
+    Utils::FileName projectDir = ProjectExplorer::Project::projectDirectory(Utils::FileName::fromString(projectPath));
+    const QString projectName = projectDir.fileName();
+
+    ProjectExplorer::ProjectMacroExpander expander(projectPath, projectName,
+                                                   k, tr("build"),
+                                                   ProjectExplorer::BuildConfiguration::Release);
+
+    QString buildPath = expander.expand(Core::DocumentManager::buildDirectory());
+    return Utils::FileName::fromString(QDir::cleanPath(QDir(projectDir.toString()).absoluteFilePath(buildPath)));
+}
+
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.h	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,44 @@
+#ifndef UBUNTU_INTERNAL_SNAPCRAFTBUILDCONFIGURATIONFACTORY_H
+#define UBUNTU_INTERNAL_SNAPCRAFTBUILDCONFIGURATIONFACTORY_H
+
+#include <projectexplorer/buildconfiguration.h>
+#include <projectexplorer/buildinfo.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class SnapcraftBuildConfigurationFactory;
+
+class SnapcraftBuildInfo : public ProjectExplorer::BuildInfo
+{
+public:
+    SnapcraftBuildInfo(const SnapcraftBuildConfigurationFactory *factory);
+};
+
+class SnapcraftBuildConfigurationFactory : public ProjectExplorer::IBuildConfigurationFactory
+{
+public:
+    SnapcraftBuildConfigurationFactory();
+
+    // IBuildConfigurationFactory interface
+    virtual QList<ProjectExplorer::BuildInfo *> availableBuilds(const ProjectExplorer::Target *parent) const override;
+
+    virtual int priority(const ProjectExplorer::Target *parent) const override;
+    virtual int priority(const ProjectExplorer::Kit *k, const QString &projectPath) const override;
+
+    virtual QList<ProjectExplorer::BuildInfo *> availableSetups(const ProjectExplorer::Kit *k, const QString &projectPath) const override;
+    virtual ProjectExplorer::BuildConfiguration *create(ProjectExplorer::Target *parent, const ProjectExplorer::BuildInfo *info) const override;
+    virtual bool canRestore(const ProjectExplorer::Target *parent, const QVariantMap &map) const override;
+    virtual ProjectExplorer::BuildConfiguration *restore(ProjectExplorer::Target *parent, const QVariantMap &map) override;
+    virtual bool canClone(const ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product) const override;
+    virtual ProjectExplorer::BuildConfiguration *clone(ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product) override;
+
+private:
+    ProjectExplorer::BuildInfo *createBuildInfo (const ProjectExplorer::Kit *k, const QString &projectPath) const;
+    Utils::FileName shadowBuildDirectory(const ProjectExplorer::Kit *k, const QString &projectPath) const;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPCRAFTBUILDCONFIGURATIONFACTORY_H
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildstepfactory.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildstepfactory.cpp	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildstepfactory.cpp	2016-10-18 07:57:32 +0000
@@ -0,0 +1,65 @@
+#include "snapcraftbuildstepfactory.h"
+#include "snapcraftrsyncstep.h"
+#include "snapcraftstep.h"
+#include "snapcraftproject.h"
+
+#include <ubuntu/ubuntuconstants.h>
+
+#include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/buildsteplist.h>
+#include <projectexplorer/target.h>
+#include <utils/algorithm.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+SnapcraftBuildStepFactory::SnapcraftBuildStepFactory(QObject *parent) : ProjectExplorer::IBuildStepFactory (parent)
+{
+
+}
+
+QList<ProjectExplorer::BuildStepInfo> SnapcraftBuildStepFactory::availableSteps(ProjectExplorer::BuildStepList *parent) const
+{
+    if (parent->id() != ProjectExplorer::Constants::BUILDSTEPS_BUILD)
+        return {};
+
+    if (!parent->target() || !qobject_cast<SnapcraftProject *>(parent->target()->project()))
+        return {};
+
+    return {
+        ProjectExplorer::BuildStepInfo(Constants::SNAPCRAFT_RSYNCBUILSSTEP_ID, tr("Prepare build")),
+        ProjectExplorer::BuildStepInfo(Constants::SNAPCRAFT_BUILDSTEP_ID, tr("Snapcraft"))
+    };
+}
+
+ProjectExplorer::BuildStep *SnapcraftBuildStepFactory::create(ProjectExplorer::BuildStepList *parent, Core::Id id)
+{
+    if (!Utils::contains(availableSteps(parent), [&id](const ProjectExplorer::BuildStepInfo &step){return id == step.id;}))
+        return nullptr;
+
+    if (id == Constants::SNAPCRAFT_RSYNCBUILSSTEP_ID) {
+        return new SnapcraftRsyncStep(parent);
+    } else if (id == Constants::SNAPCRAFT_BUILDSTEP_ID) {
+        return new SnapcraftStep(parent);
+    }
+
+    return nullptr;
+}
+
+ProjectExplorer::BuildStep *SnapcraftBuildStepFactory::clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product)
+{
+    Core::Id id = product->id();
+    if (!Utils::contains(availableSteps(parent), [&id](const ProjectExplorer::BuildStepInfo &step){return id == step.id;}))
+        return nullptr;
+
+    if (id == Constants::SNAPCRAFT_RSYNCBUILSSTEP_ID) {
+        return new SnapcraftRsyncStep(parent, static_cast<SnapcraftRsyncStep *>(product));
+    } else if (id == Constants::SNAPCRAFT_BUILDSTEP_ID) {
+        return new SnapcraftStep(parent, static_cast<SnapcraftStep *>(product));
+    }
+
+    return nullptr;
+}
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildstepfactory.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildstepfactory.h	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftbuildstepfactory.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,25 @@
+#ifndef UBUNTU_INTERNAL_SNAPCRAFTBUILDSTEPFACTORY_H
+#define UBUNTU_INTERNAL_SNAPCRAFTBUILDSTEPFACTORY_H
+
+#include <projectexplorer/buildstep.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class SnapcraftBuildStepFactory : public ProjectExplorer::IBuildStepFactory
+{
+    Q_OBJECT
+public:
+    SnapcraftBuildStepFactory(QObject *parent = nullptr);
+
+    // IBuildStepFactory interface
+public:
+    virtual QList<ProjectExplorer::BuildStepInfo> availableSteps(ProjectExplorer::BuildStepList *parent) const override;
+    virtual ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, Core::Id id) override;
+    virtual ProjectExplorer::BuildStep *clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product) override;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPCRAFTBUILDSTEPFACTORY_H
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftproject.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftproject.cpp	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftproject.cpp	2016-10-18 07:57:32 +0000
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 2.1.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Benjamin Zeller <[e-mail]>
+ */
+
+#include "snapcraftproject.h"
+#include "snapcraftprojectnode.h"
+
+#include <coreplugin/modemanager.h>
+#include <coreplugin/icontext.h>
+#include <coreplugin/documentmanager.h>
+#include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/kitinformation.h>
+#include <projectexplorer/toolchain.h>
+#include <projectexplorer/projectmacroexpander.h>
+#include <qmljs/qmljssimplereader.h>
+#include <qtsupport/qtkitinformation.h>
+#include <qtsupport/qtsupportconstants.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#include <yaml-cpp/yaml.h>
+#pragma GCC diagnostic pop
+
+
+using namespace Ubuntu;
+using namespace Ubuntu::Internal;
+
+SnapcraftProject::SnapcraftProject(SnapcraftProjectManager *manager, const Utils::FileName &fileName)
+    : m_manager(manager),
+      m_fileName(fileName),
+      m_watcher(new QFileSystemWatcher)
+{
+
+    setId(Constants::SNAPCRAFT_PROJECT_ID);
+
+    setProjectContext(Core::Context(Constants::SNAPCRAFT_PROJECT_PROJECTCONTEXT));
+
+
+    m_file = QPointer<SnapcraftProjectFile>(new SnapcraftProjectFile());
+    Core::DocumentManager::addDocument(m_file.data(), true);
+    setDocument(m_file.data());
+
+    m_file->setFilePath(fileName);
+
+    m_rootNode = QSharedPointer<SnapcraftProjectNode>(new SnapcraftProjectNode(this, fileName, &m_watcher));
+
+    ProjectExplorer::FileNode *projectFileNode = new ProjectExplorer::FileNode(fileName, ProjectExplorer::ProjectFileType, false);
+    m_rootNode->addFileNodes({projectFileNode});
+
+    connect(m_file, &SnapcraftProjectFile::changed, this, &SnapcraftProject::asyncUpdate);
+
+    //we show magic directories that are not listed in the snapcraft.yaml file, therefore we need to watch the directory
+    //if one of those is changed or removed
+    m_watcher.addPath(projectDirectory().toFileInfo().absoluteFilePath());
+    connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this, &SnapcraftProject::maybeUpdate);
+
+    QMetaObject::invokeMethod(this, "asyncUpdate", Qt::QueuedConnection);
+}
+
+QString SnapcraftProject::displayName() const {
+    return m_rootNode->displayName();
+}
+
+ProjectExplorer::IProjectManager *SnapcraftProject::projectManager() const {
+    return m_manager;
+}
+
+ProjectExplorer::ProjectNode *SnapcraftProject::rootProjectNode() const {
+    return m_rootNode.data();
+}
+
+QStringList SnapcraftProject::files(FilesMode) const {
+    QStringList files;
+    //enumChild(projectDir(), files);
+    return files;
+}
+
+bool SnapcraftProject::supportsKit(ProjectExplorer::Kit *, QString *) const
+{
+#if 0
+    UbuntuKitMatcher matcher;
+    if (!matcher.matches(k)) {
+        if(errorMessage)
+            *errorMessage = tr("Only Desktop and Ubuntu Kits are supported");
+        return false;
+    }
+#endif
+    return true;
+}
+
+bool SnapcraftProject::needsConfiguration() const
+{
+    return targets().size() == 0;
+}
+
+bool SnapcraftProject::requiresTargetPanel() const
+{
+    return true;
+}
+
+QString SnapcraftProject::shadowBuildDirectory(const QString &proFilePath
+                                            , const ProjectExplorer::Kit *k
+                                            , const QString &suffix
+                                            , const ProjectExplorer::BuildConfiguration::BuildType buildType)
+{
+    if (proFilePath.isEmpty())
+        return QString();
+
+    QFileInfo info(proFilePath);
+
+    QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(k);
+    if (version)
+        return info.absolutePath();
+
+    const QString projectName = QFileInfo(proFilePath).completeBaseName();
+    ProjectExplorer::ProjectMacroExpander expander(proFilePath, projectName, k, suffix, buildType);
+    QDir projectDir = QDir(projectDirectory(Utils::FileName::fromString(proFilePath)).toString());
+    QString buildPath = expander.expand(Core::DocumentManager::buildDirectory());
+    return QDir::cleanPath(projectDir.absoluteFilePath(buildPath));
+}
+
+void SnapcraftProject::asyncUpdate()
+{
+    qDebug()<<"Syncing from yaml";
+    try {
+        YAML::Node yaml = YAML::LoadFile(m_fileName.toString().toStdString());
+        if (!m_rootNode->syncFromYAMLNode(yaml)) {
+            qDebug()<<"Invalid YAML file";
+        }
+    } catch (const YAML::Exception &e) {
+        qDebug() << e.what();
+    }
+
+    emit displayNameChanged();
+}
+
+void SnapcraftProject::maybeUpdate(const QString &pathChanged)
+{
+    if (QFileInfo(pathChanged) == projectDirectory().toFileInfo()) {
+        asyncUpdate();
+    }
+}
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftproject.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftproject.h	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftproject.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 2.1.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Benjamin Zeller <[e-mail]>
+ */
+
+#ifndef SNAPCRAFTPROJECT_H
+#define SNAPCRAFTPROJECT_H
+
+#include "snapcraftprojectmanager.h"
+#include "snapcraftprojectfile.h"
+
+#include <ubuntu/ubuntuconstants.h>
+
+#include <projectexplorer/buildconfiguration.h>
+#include <projectexplorer/projectnodes.h>
+#include <projectexplorer/project.h>
+
+#include <QPointer>
+#include <QFileSystemWatcher>
+
+#include <yaml-cpp/node/node.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class UbuntuProjectManager;
+class SnapcraftProjectNode;
+
+class SnapcraftProject : public ProjectExplorer::Project
+{
+    Q_OBJECT
+
+public:
+    SnapcraftProject(SnapcraftProjectManager *manager, const Utils::FileName &fileName);
+
+    QString displayName() const override;
+    ProjectExplorer::IProjectManager *projectManager() const override;
+
+    ProjectExplorer::ProjectNode *rootProjectNode() const override;
+    QStringList files(FilesMode fileMode) const override;
+
+    QDir projectDir() const {
+        return projectDirectory().toString();
+    }
+
+    QString filesFileName() const {
+        return m_fileName.toString();
+    }
+
+    // Project interface
+    bool supportsKit(ProjectExplorer::Kit *k, QString *errorMessage) const override;
+    bool needsConfiguration() const override;
+    bool requiresTargetPanel() const override;
+
+    static QString shadowBuildDirectory(const QString &proFilePath, const ProjectExplorer::Kit *k,
+                                        const QString &suffix = QString(),
+                                        const ProjectExplorer::BuildConfiguration::BuildType buildType = ProjectExplorer::BuildConfiguration::Unknown);
+
+protected slots:
+    void asyncUpdate ();
+    void maybeUpdate (const QString &pathChanged);
+
+private:
+    SnapcraftProjectManager *m_manager;
+    QString m_projectName;
+    QPointer<SnapcraftProjectFile> m_file;
+
+    Utils::FileName m_fileName;
+    QSharedPointer<SnapcraftProjectNode> m_rootNode;
+    QFileSystemWatcher m_watcher;
+};
+}
+}
+
+#endif // SNAPCRAFTPROJECT_H
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectfile.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectfile.cpp	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectfile.cpp	2016-10-18 07:57:32 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 2.1.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Benjamin Zeller <[e-mail]>
+ */
+
+#include "snapcraftprojectfile.h"
+
+using namespace Ubuntu::Internal;
+
+SnapcraftProjectFile::SnapcraftProjectFile(Core::Id id)
+    : TextEditor::TextDocument(id)
+{
+}
+
+Core::IDocument::ReloadBehavior SnapcraftProjectFile::reloadBehavior(Core::IDocument::ChangeTrigger state, Core::IDocument::ChangeType type) const
+{
+    Q_UNUSED(state)
+    Q_UNUSED(type)
+    return BehaviorSilent;
+}
+
+bool SnapcraftProjectFile::reload(QString *errorString, Core::IDocument::ReloadFlag flag, Core::IDocument::ChangeType type)
+{
+    if (type != TypePermissions) {
+        emit changed();
+    }
+
+    return TextDocument::reload(errorString, flag, type);
+}
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectfile.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectfile.h	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectfile.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 2.1.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Benjamin Zeller <[e-mail]>
+ */
+
+#ifndef SNAPCRAFTPROJECTFILE_H
+#define SNAPCRAFTPROJECTFILE_H
+
+#include <QObject>
+#include <ubuntu/ubuntuconstants.h>
+
+#include <texteditor/textdocument.h>
+#include <utils/fileutils.h>
+
+namespace Ubuntu {
+namespace Internal {
+class SnapcraftProject;
+class SnapcraftProjectFile : public TextEditor::TextDocument
+{
+    Q_OBJECT
+public:
+    SnapcraftProjectFile(Core::Id id = Core::Id());
+
+    // IDocument interface
+    virtual ReloadBehavior reloadBehavior(ChangeTrigger state, ChangeType type) const override;
+    virtual bool reload(QString *errorString, ReloadFlag flag, ChangeType type) override;
+
+signals:
+    void changed ();
+
+};
+}
+}
+
+#endif // SNAPCRAFTPROJECTFILE_H
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectmanager.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectmanager.cpp	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectmanager.cpp	2016-10-18 07:57:32 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 2.1.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Benjamin Zeller <[e-mail]>
+ */
+
+#include "snapcraftprojectmanager.h"
+#include "snapcraftproject.h"
+
+#include <ubuntu/ubuntuconstants.h>
+
+#include <projectexplorer/session.h>
+#include <coreplugin/idocument.h>
+#include <utils/fileutils.h>
+
+#include <QFileInfo>
+
+
+namespace Ubuntu {
+namespace Internal {
+
+SnapcraftProjectManager::SnapcraftProjectManager()
+{
+
+}
+
+QString SnapcraftProjectManager::mimeType() const
+{
+    return QLatin1String(Constants::SNAPCRAFT_PROJECT_MIMETYPE);
+}
+
+ProjectExplorer::Project *SnapcraftProjectManager::openProject(const QString &fileName, QString *errorString)
+{
+    QFileInfo fileInfo(fileName);
+
+    foreach (ProjectExplorer::Project *pi, ProjectExplorer::SessionManager::projects()) {
+        if (fileName == pi->document()->filePath().toString()) {
+            if (errorString)
+                *errorString = tr("Failed opening project '%1': Project already open") .arg(QDir::toNativeSeparators(fileName));
+            return 0;
+        }
+    }
+
+    if (fileInfo.isFile())
+        return new SnapcraftProject(this, Utils::FileName(fileInfo));
+
+    *errorString = tr("Failed opening project '%1': Project file is not a file").arg(QDir::toNativeSeparators(fileName));
+    return 0;
+}
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectmanager.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectmanager.h	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectmanager.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 2.1.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Benjamin Zeller <[e-mail]>
+ */
+
+#ifndef UBUNTU_INTERNAL_SNAPCRAFTPROJECTMANAGER_H
+#define UBUNTU_INTERNAL_SNAPCRAFTPROJECTMANAGER_H
+
+#include <projectexplorer/iprojectmanager.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class SnapcraftProjectManager : public ProjectExplorer::IProjectManager
+{
+public:
+    SnapcraftProjectManager();
+
+    // IProjectManager interface
+    virtual QString mimeType() const override;
+    virtual ProjectExplorer::Project *openProject(const QString &fileName, QString *errorString) override;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPCRAFTPROJECTMANAGER_H
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectnode.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectnode.cpp	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectnode.cpp	2016-10-18 07:57:32 +0000
@@ -0,0 +1,496 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 2.1.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Benjamin Zeller <[e-mail]>
+ */
+
+#include "snapcraftprojectnode.h"
+
+#include <projectexplorer/nodesvisitor.h>
+#include <coreplugin/fileiconprovider.h>
+#include <ubuntu/ubuntuconstants.h>
+
+#include <QFileInfo>
+#include <QDir>
+#include <QTimer>
+#include <QFileSystemWatcher>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#include <yaml-cpp/yaml.h>
+#pragma GCC diagnostic pop
+
+namespace Ubuntu {
+namespace Internal {
+
+static QIcon generateIcon(const QString &overlay) {
+    const QSize desiredSize = QSize(16, 16);
+
+    const QPixmap overlayPixmap(overlay);
+    const QIcon overlayIcon(overlayPixmap.scaled(12, 12));
+    const QPixmap pixmap
+            = Core::FileIconProvider::overlayIcon(QStyle::SP_DirIcon, overlayIcon, desiredSize);
+
+    QIcon result;
+    result.addPixmap(pixmap);
+
+    return result;
+}
+
+static QIcon generateProjectIcon () {
+    static QIcon projectIcon;
+    if (projectIcon.isNull())
+        projectIcon = generateIcon(QString::fromLatin1(Constants::UBUNTU_ICON));
+
+    return projectIcon;
+}
+
+SnapcraftProjectNode::SnapcraftProjectNode(SnapcraftProject *rootProject, const Utils::FileName &projectFilePath, QFileSystemWatcher *watcher)
+    : ProjectExplorer::ProjectNode (projectFilePath),
+      m_rootProject(rootProject),
+      m_watcher(watcher)
+{
+    setDisplayName(projectFilePath.parentDir().toString());
+    setIcon(generateProjectIcon());
+}
+
+SnapcraftProjectNode::~SnapcraftProjectNode()
+{
+    if (m_watcher) {
+
+    }
+}
+
+bool SnapcraftProjectNode::syncFromYAMLNode(YAML::Node rootNode)
+{
+    qDebug()<<"Sync from YAML node";
+    try {
+        QString displayName = QString::fromStdString(rootNode["name"].as<std::string>());
+        setDisplayName(displayName);
+
+        YAML::Node parts = rootNode["parts"];
+        if (!parts.IsMap()) {
+            qDebug()<<"Parts is not a map";
+            return false;
+        }
+
+        QList<ProjectExplorer::FolderNode *> existingNodes = subFolderNodes();
+        QList<ProjectExplorer::FolderNode *> nodesToRemove;
+        QList<ProjectExplorer::FolderNode *> nodesToAdd;
+
+        QStringList partsFromYaml;
+        QStringList existingParts;
+
+        for (const auto &part : existingNodes) {
+            existingParts << part->displayName();
+        }
+
+        //iterate over the parts
+        for (auto it = parts.begin(); it != parts.end(); ++it) {
+
+            YAML::Node subProject = it->second;
+            QString partName = QString::fromStdString(it->first.as<std::string>());
+            //QString subType  = QString::fromStdString(subProject["plugin"].as<std::string>());
+            QString source   = QDir::cleanPath(QString::fromStdString(subProject["source"].as<std::string>()));
+
+            partsFromYaml << partName;
+
+            // We only show a part if it locally exists and is a directory
+            QString sourcePathName = QDir::cleanPath(filePath().parentDir().appendPath(source).toString());
+            Utils::FileName sourcePath = Utils::FileName::fromString(sourcePathName);
+            if (sourcePath.exists() && sourcePath.toFileInfo().isDir()) {
+
+                int idx = existingParts.indexOf(partName);
+                if (idx >= 0) {
+                    //check if source is still the same
+                    SnapcraftGenericPartNode *n = static_cast<SnapcraftGenericPartNode *>(existingNodes.at(idx));
+                    if (n->filePath() == sourcePath)
+                        continue;
+
+                    nodesToRemove << n;
+                }
+
+                SnapcraftGenericPartNode *partNode =  new SnapcraftGenericPartNode(partName, sourcePath, m_watcher);
+                nodesToAdd << partNode;
+            }
+        }
+
+
+        //snapcraft has magic directories, like setup, we want to show in the project tree
+        QStringList magicSnapcraftDirs{
+            QStringLiteral("setup")
+        };
+
+        for (const QString &magicDir: magicSnapcraftDirs) {
+            Utils::FileName dirPath = filePath().parentDir().appendPath(magicDir);
+            if (dirPath.exists()) {
+                partsFromYaml << magicDir;
+                if(!existingParts.contains(magicDir)) {
+                    SnapcraftGenericPartNode *partNode =  new SnapcraftGenericPartNode(magicDir, dirPath, m_watcher);
+                    nodesToAdd << partNode;
+                }
+            }
+        }
+
+        QSet<QString> obsoleteParts = existingParts.toSet() - partsFromYaml.toSet();
+        qDebug()<<"Parts in yaml"<<partsFromYaml;
+        qDebug()<<"Currently known parts"<<existingParts;
+        qDebug()<<"Parts now obsolete: "<<obsoleteParts;
+        for (const auto &part : obsoleteParts) {
+            int idx = existingParts.indexOf(part);
+            if (idx >= 0)
+                nodesToRemove << existingNodes.at(idx);
+        }
+
+        //remove old nodes
+        removeFolderNodes(nodesToRemove);
+        addFolderNodes(nodesToAdd);
+    } catch (const YAML::Exception &e) {
+        qDebug()<<"ERRROR ERROR ERROR "<<e.what();
+        return false;
+    }
+
+    return true;
+}
+
+/*!
+    \class Ubuntu::Internal::SnapcraftGenericPartNode
+    \brief The SnapcraftGenericPartNode class
+    Fallback node if the subproject type can not be handled by the plugin directly
+ */
+
+static void enumChild(const QDir &dir, QSet<Utils::FileName> &dirs, QSet<Utils::FileName> &res) {
+    foreach (const QFileInfo &info, dir.entryInfoList(QDir::NoDotAndDotDot|QDir::Dirs|QDir::Files|QDir::Hidden)) {
+        if (info.isDir()) {
+            dirs << Utils::FileName(info);
+            enumChild(QDir(info.absoluteFilePath()), dirs, res);
+        } else {
+            res.insert(Utils::FileName(info));
+        }
+    }
+}
+
+SnapcraftGenericPartNode::SnapcraftGenericPartNode(const QString &partName, const Utils::FileName &folderPath, QFileSystemWatcher *watcher)
+    : ProjectExplorer::FolderNode (folderPath, ProjectExplorer::FolderNodeType, partName)
+    , m_watcher(watcher)
+{
+    scheduleProjectScan();
+
+    setIcon(generateProjectIcon());
+
+    if (watcher->addPath(folderPath.toString())) {
+        qDebug()<<"Added"<<folderPath.toString()<<"to watcher";
+    } else {
+        qDebug()<<"Failed to add"<<folderPath.toString()<<"to watcher";
+    }
+    m_watcherConnection = QObject::connect(watcher, &QFileSystemWatcher::directoryChanged, [this](const QString &path){
+        maybeScheduleProjectScan(path);
+    });
+}
+
+SnapcraftGenericPartNode::~SnapcraftGenericPartNode()
+{
+    //@BUG the watcher is still watching all the subdirs and files!
+    if (m_watcher) {
+        QString myPath = filePath().toFileInfo().absoluteFilePath();
+        QStringList watched = m_watcher->directories();
+        QStringList toRemove;
+        for(const QString &path: watched) {
+            if(path.startsWith(myPath))
+                toRemove << path;
+        }
+        m_watcher->removePaths(toRemove);
+        QObject::disconnect(m_watcherConnection);
+    }
+}
+
+void SnapcraftGenericPartNode::maybeScheduleProjectScan(const QString &changedPath)
+{
+    Utils::FileName changed = Utils::FileName::fromString(changedPath);
+    if (filePath().toFileInfo() == changed.toFileInfo())
+        scheduleProjectScan();
+}
+
+void SnapcraftGenericPartNode::scheduleProjectScan()
+{
+    if (m_scanning)
+        return;
+
+    qDebug()<<"Scheduling Project scan";
+
+    m_scanning = true;
+
+    QTimer *rescanTimer = new QTimer();
+    rescanTimer->setSingleShot(true);
+    rescanTimer->start(0);
+    QObject::connect(rescanTimer, &QTimer::timeout, [this, rescanTimer](){
+        qDebug()<<"Starting Project scan";
+        delete rescanTimer;
+        this->scanProjectDirectory();
+
+        m_scanning = false;
+    });
+}
+
+void SnapcraftGenericPartNode::removeFileNodes(const QList<Utils::FileName> &files)
+{
+    foreach(const Utils::FileName &f, files) {
+        if(f.toFileInfo().isDir())
+            continue;
+
+        FindFileNodesForFileVisitor vis(f);
+        this->accept(&vis);
+
+        for (ProjectExplorer::FileNode *node : vis.nodes()) {
+            node->parentFolderNode()->removeFileNodes({node});
+        }
+    }
+}
+
+void SnapcraftGenericPartNode::removeFolderNodes(QList<Utils::FileName> &dirs)
+{
+
+    qSort(dirs.begin(), dirs.end(),[](const Utils::FileName &a, const Utils::FileName &b){
+        return a.toFileInfo().absoluteFilePath() > b.toFileInfo().absoluteFilePath();
+    });
+
+    foreach(const Utils::FileName &f, dirs) {
+        FindNodesForFolderVisitor vis(f);
+        this->accept(&vis);
+
+        FindNodesForFolderVisitor visParent(f.parentDir());
+        this->accept(&visParent);
+
+        if(visParent.nodes().size()) {
+            m_watcher->removePath(f.toFileInfo().absoluteFilePath());
+            visParent.nodes()[0]->removeFolderNodes(vis.nodes());
+        }
+    }
+}
+
+QList<ProjectExplorer::ProjectAction> SnapcraftGenericPartNode::supportedActions(ProjectExplorer::Node *node) const
+{
+    static const QList<ProjectExplorer::ProjectAction> fileActions {
+        ProjectExplorer::ProjectAction::Rename,
+        ProjectExplorer::ProjectAction::RemoveFile
+    };
+    static const QList<ProjectExplorer::ProjectAction> folderActions {
+        ProjectExplorer::ProjectAction::AddNewFile,
+        ProjectExplorer::ProjectAction::RemoveFile
+    };
+    switch (node->nodeType()) {
+    case ProjectExplorer::FileNodeType:
+        return fileActions;
+    case ProjectExplorer::FolderNodeType:
+    case ProjectExplorer::ProjectNodeType:
+        return folderActions;
+    default:
+        return ProjectExplorer::FolderNode::supportedActions(node);
+    }
+}
+
+bool SnapcraftGenericPartNode::addFiles(const QStringList &, QStringList *)
+{
+    return true;
+}
+
+bool SnapcraftGenericPartNode::removeFiles(const QStringList &, QStringList *)
+{
+    return true;
+}
+
+bool SnapcraftGenericPartNode::deleteFiles(const QStringList &)
+{
+    return true;
+}
+
+void SnapcraftGenericPartNode::scanProjectDirectory()
+{
+    QSet<Utils::FileName> dirs;
+    QSet<Utils::FileName> files;
+    enumChild(QDir(filePath().toString()), dirs, files);
+
+    FindFilesAndDirsVisitor vis;
+    this->accept(&vis);
+
+    QSet<Utils::FileName> oldFiles = QSet<Utils::FileName>::fromList(vis.filePaths());
+    QSet<Utils::FileName> oldDirs  = QSet<Utils::FileName>::fromList(vis.dirPaths());
+    QSet<Utils::FileName> newFiles(files);
+    QSet<Utils::FileName> newDirs(dirs);
+
+    QSet<Utils::FileName> filesToRemove = oldFiles - newFiles;
+    QSet<Utils::FileName> filesToAdd    = newFiles - oldFiles;
+    QList<Utils::FileName> dirsToRemove  = (oldDirs - newDirs).toList();
+    QSet<Utils::FileName> dirsToAdd     = newDirs - oldDirs;
+
+    qDebug()<<"Removing dirs " <<dirsToRemove;
+    qDebug()<<"Adding dirs   " <<dirsToAdd;
+    qDebug()<<"Removing files" <<filesToRemove;
+    qDebug()<<"Adding files  " <<filesToAdd;
+
+    removeFileNodes(filesToRemove.toList());
+    removeFolderNodes(dirsToRemove);
+
+    for (const Utils::FileName &dir :  dirsToAdd) {
+        Utils::FileName relativeName = dir.relativeChildPath(filePath());
+        QStringList relativeNameList = relativeName.toUserOutput().split(QDir::separator());
+        createOrFindFolder(relativeNameList);
+    }
+
+    for (const Utils::FileName &file :  filesToAdd) {
+        Utils::FileName folderPath = file.parentDir();
+
+        //do not show the project file twice
+        if (file == projectNode()->filePath())
+            continue;
+
+        ProjectExplorer::FolderNode *parentNode = nullptr;
+        if (folderPath == filePath()) {
+            parentNode = this;
+        } else {
+            Utils::FileName relativeName = folderPath.relativeChildPath(filePath());
+            QStringList relativeNameList = relativeName.toUserOutput().split(QDir::separator());
+            parentNode = createOrFindFolder(relativeNameList);
+        }
+
+        ProjectExplorer::FileNode *fNode = new ProjectExplorer::FileNode(file, ProjectExplorer::UnknownFileType, false);
+        parentNode->addFileNodes({fNode});
+    }
+}
+
+ProjectExplorer::FolderNode *SnapcraftGenericPartNode::createOrFindFolder(const QStringList &folder)
+{
+    QStringList watches;
+    ProjectExplorer::FolderNode *currFolder = this;
+
+    Utils::FileName currentPath = filePath();
+
+    for (const QString &folderName: folder) {
+
+        QList<ProjectExplorer::FolderNode *> subnodes = currFolder->subFolderNodes();
+        currentPath = currentPath.appendPath(folderName);
+
+        auto check = [&folderName](ProjectExplorer::FolderNode *f) {
+            return f->filePath().fileName() == folderName;
+        };
+
+        auto it = std::find_if(subnodes.begin(), subnodes.end(), check);
+
+        if (it != subnodes.end()) {
+            //node exists already
+            currFolder = *it;
+            continue;
+        }
+
+        //does not exist lets create a new one
+        ProjectExplorer::FolderNode *fNode = new SnapcraftGenericPartFolderNode(currentPath, ProjectExplorer::FolderNodeType, folderName);
+        currFolder->addFolderNodes({fNode});
+        currFolder = fNode;
+
+        watches << currentPath.toFileInfo().absoluteFilePath();
+    }
+    qDebug()<<"Failed to add watches: "<<m_watcher->addPaths(watches);
+    return currFolder;
+}
+
+Utils::FileNameList FindFilesAndDirsVisitor::filePaths() const
+{
+    return m_filePaths;
+}
+
+Utils::FileNameList FindFilesAndDirsVisitor::dirPaths() const
+{
+    return m_dirPaths;
+}
+
+void FindFilesAndDirsVisitor::visitProjectNode(ProjectExplorer::ProjectNode *projectNode)
+{
+    visitFolderNode(projectNode);
+}
+
+void FindFilesAndDirsVisitor::visitFolderNode(ProjectExplorer::FolderNode *folderNode)
+{
+    if (folderNode->nodeType() != ProjectExplorer::ProjectNodeType)
+        m_dirPaths.append(folderNode->filePath());
+
+    for (const ProjectExplorer::FileNode *fileNode : folderNode->fileNodes())
+        m_filePaths.append(fileNode->filePath());
+}
+
+FindFileNodesForFileVisitor::FindFileNodesForFileVisitor(const Utils::FileName &f)
+    : m_file(f)
+{
+
+}
+
+QList<ProjectExplorer::FileNode *> FindFileNodesForFileVisitor::nodes() const
+{
+    return m_nodes;
+}
+
+void FindFileNodesForFileVisitor::visitProjectNode(ProjectExplorer::ProjectNode *projectNode)
+{
+    visitFolderNode(projectNode);
+}
+
+void FindFileNodesForFileVisitor::visitFolderNode(ProjectExplorer::FolderNode *folderNode)
+{
+    for(auto fileNode: folderNode->fileNodes()) {
+        if (fileNode->filePath() == m_file)
+            m_nodes.append(fileNode);
+    }
+}
+
+FindNodesForFolderVisitor::FindNodesForFolderVisitor(const Utils::FileName &f)
+    : m_folder(f)
+{
+
+}
+
+QList<ProjectExplorer::FolderNode *> FindNodesForFolderVisitor::nodes() const
+{
+    return m_nodes;
+}
+
+void FindNodesForFolderVisitor::visitProjectNode(ProjectExplorer::ProjectNode *)
+{
+    return;
+}
+
+void FindNodesForFolderVisitor::visitFolderNode(ProjectExplorer::FolderNode *folderNode)
+{
+    if (m_folder == folderNode->filePath())
+        m_nodes.append(folderNode);
+}
+
+bool SnapcraftGenericPartFolderNode::addFiles(const QStringList &, QStringList *)
+{
+    return true;
+}
+
+bool SnapcraftGenericPartFolderNode::removeFiles(const QStringList &, QStringList *)
+{
+    return true;
+}
+
+bool SnapcraftGenericPartFolderNode::deleteFiles(const QStringList &)
+{
+    return true;
+}
+
+
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectnode.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectnode.h	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftprojectnode.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 2.1.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Benjamin Zeller <[e-mail]>
+ */
+
+#ifndef UBUNTU_INTERNAL_SNAPCRAFTPROJECTNODE_H
+#define UBUNTU_INTERNAL_SNAPCRAFTPROJECTNODE_H
+
+#include <projectexplorer/projectnodes.h>
+#include <projectexplorer/nodesvisitor.h>
+#include <yaml-cpp/node/node.h>
+
+#include <QPointer>
+
+class QFileSystemWatcher;
+
+namespace Ubuntu {
+namespace Internal {
+
+class FindFilesAndDirsVisitor : public ProjectExplorer::NodesVisitor {
+public:
+    Utils::FileNameList filePaths() const;
+    Utils::FileNameList dirPaths() const;
+
+    void visitProjectNode(ProjectExplorer::ProjectNode *projectNode) override;
+    void visitFolderNode(ProjectExplorer::FolderNode *folderNode) override;
+
+private:
+    Utils::FileNameList m_filePaths;
+    Utils::FileNameList m_dirPaths;
+};
+
+class FindFileNodesForFileVisitor : public ProjectExplorer::NodesVisitor {
+
+public:
+    FindFileNodesForFileVisitor (const Utils::FileName &f);
+    QList<ProjectExplorer::FileNode *> nodes () const;
+
+    void visitProjectNode(ProjectExplorer::ProjectNode *projectNode) override;
+    void visitFolderNode(ProjectExplorer::FolderNode *folderNode) override;
+
+private:
+    Utils::FileName m_file;
+    QList<ProjectExplorer::FileNode *> m_nodes;
+};
+
+class FindNodesForFolderVisitor : public ProjectExplorer::NodesVisitor {
+
+public:
+    FindNodesForFolderVisitor (const Utils::FileName &f);
+    QList<ProjectExplorer::FolderNode *> nodes () const;
+
+    void visitProjectNode(ProjectExplorer::ProjectNode *projectNode) override;
+    void visitFolderNode(ProjectExplorer::FolderNode *folderNode) override;
+
+private:
+    Utils::FileName m_folder;
+    QList<ProjectExplorer::FolderNode *> m_nodes;
+};
+
+class SnapcraftProject;
+class SnapcraftGenericPartNode;
+
+class SnapcraftProjectNode : public ProjectExplorer::ProjectNode
+{
+public:
+    SnapcraftProjectNode(SnapcraftProject *rootProject, const Utils::FileName &projectFilePath, QFileSystemWatcher *watcher);
+    ~SnapcraftProjectNode();
+
+    bool syncFromYAMLNode(YAML::Node rootNode);
+
+private:
+    SnapcraftProject *m_rootProject = nullptr;
+    QPointer<QFileSystemWatcher> m_watcher;
+};
+
+class SnapcraftGenericPartFolderNode : public ProjectExplorer::FolderNode
+{
+public:
+
+    using ProjectExplorer::FolderNode::FolderNode;
+
+    // FolderNode interface
+    virtual bool addFiles(const QStringList &filePaths, QStringList *notAdded) override;
+    virtual bool removeFiles(const QStringList &filePaths, QStringList *notRemoved) override;
+    virtual bool deleteFiles(const QStringList &filePaths) override;
+};
+
+class SnapcraftGenericPartNode : public ProjectExplorer::FolderNode
+{
+public:
+    SnapcraftGenericPartNode(const QString &partName, const Utils::FileName &folderPath, QFileSystemWatcher *watcher);
+    ~SnapcraftGenericPartNode();
+
+    void maybeScheduleProjectScan(const QString &changedPath);
+    void scheduleProjectScan();
+
+    using ProjectExplorer::FolderNode::removeFileNodes;
+    void removeFileNodes (const QList<Utils::FileName> &files);
+
+    using ProjectExplorer::FolderNode::removeFolderNodes;
+    void removeFolderNodes (QList<Utils::FileName> &dirs);
+
+    // Node interface
+    virtual QList<ProjectExplorer::ProjectAction> supportedActions(ProjectExplorer::Node *node) const override;
+    virtual bool addFiles(const QStringList &filePaths, QStringList *notAdded) override;
+    virtual bool removeFiles(const QStringList &filePaths, QStringList *notRemoved) override;
+    virtual bool deleteFiles(const QStringList &filePaths) override;
+
+protected:
+    ProjectExplorer::FolderNode *createOrFindFolder (const QStringList &folder);
+    void scanProjectDirectory ();
+
+private:
+    bool m_scanning = false;
+    QMetaObject::Connection m_watcherConnection;
+    QPointer<QFileSystemWatcher> m_watcher;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPCRAFTPROJECTNODE_H
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftrsyncstep.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftrsyncstep.cpp	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftrsyncstep.cpp	2016-10-18 07:57:32 +0000
@@ -0,0 +1,51 @@
+#include "snapcraftrsyncstep.h"
+#include "snapcraftproject.h"
+#include "snapcraftbuildconfiguration.h"
+
+#include <ubuntu/ubuntuconstants.h>
+
+#include <projectexplorer/target.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+SnapcraftRsyncStep::SnapcraftRsyncStep(ProjectExplorer::BuildStepList *bsl)
+    : ProjectExplorer::AbstractProcessStep(bsl, Constants::SNAPCRAFT_RSYNCBUILSSTEP_ID)
+{
+    setDefaultDisplayName(tr("Prepare build"));
+}
+
+SnapcraftRsyncStep::SnapcraftRsyncStep(ProjectExplorer::BuildStepList *bsl, SnapcraftRsyncStep *bs)
+    : ProjectExplorer::AbstractProcessStep(bsl, bs)
+{
+
+}
+
+bool SnapcraftRsyncStep::init(QList<const ProjectExplorer::BuildStep *> &)
+{
+    QString projectDir = target()->project()->projectDirectory().toString();
+
+    ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration();
+    if(!bc)
+        return false;
+
+    ProjectExplorer::ProcessParameters *param = processParameters();
+    param->setWorkingDirectory(bc->buildDirectory().toUserOutput());
+    param->setCommand(QStringLiteral("rsync"));
+    param->setArguments(QString::fromLatin1("-a --delete \"%1/\" \"./\"")
+                        .arg(QDir::cleanPath(projectDir)));
+    param->setMacroExpander(bc->macroExpander());
+    param->setEnvironment(bc->environment());
+
+    return true;
+}
+
+ProjectExplorer::BuildStepConfigWidget *SnapcraftRsyncStep::createConfigWidget()
+{
+    return new ProjectExplorer::SimpleBuildStepConfigWidget(this);
+}
+
+
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftrsyncstep.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftrsyncstep.h	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftrsyncstep.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,31 @@
+#ifndef UBUNTU_INTERNAL_SNAPCRAFTRSYNCSTEP_H
+#define UBUNTU_INTERNAL_SNAPCRAFTRSYNCSTEP_H
+
+#include <projectexplorer/abstractprocessstep.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class SnapcraftBuildStepFactory;
+class SnapcraftBuildConfigurationFactory;
+
+class SnapcraftRsyncStep : public ProjectExplorer::AbstractProcessStep
+{
+    Q_OBJECT
+public:
+    friend class SnapcraftBuildStepFactory;
+    friend class SnapcraftBuildConfigurationFactory;
+
+    // BuildStep interface
+    virtual bool init(QList<const ProjectExplorer::BuildStep *> &earlierSteps) override;
+    virtual ProjectExplorer::BuildStepConfigWidget *createConfigWidget() override;
+
+protected:
+    SnapcraftRsyncStep(ProjectExplorer::BuildStepList *bsl);
+    SnapcraftRsyncStep(ProjectExplorer::BuildStepList *bsl, SnapcraftRsyncStep *bs);
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPCRAFTRSYNCSTEP_H
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftstep.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftstep.cpp	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftstep.cpp	2016-10-18 07:57:32 +0000
@@ -0,0 +1,67 @@
+#include "snapcraftstep.h"
+#include "snapcraftproject.h"
+#include "snapcraftbuildconfiguration.h"
+
+#include <ubuntu/snap/settings/snapcraftkitinformation.h>
+
+#include <ubuntu/ubuntuconstants.h>
+
+#include <projectexplorer/target.h>
+#include <utils/environment.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+SnapcraftStep::SnapcraftStep(ProjectExplorer::BuildStepList *bsl)
+    : ProjectExplorer::AbstractProcessStep(bsl, Constants::SNAPCRAFT_BUILDSTEP_ID)
+{
+    setDefaultDisplayName(tr("Snapcraft"));
+}
+
+SnapcraftStep::SnapcraftStep(ProjectExplorer::BuildStepList *bsl, SnapcraftStep *bs)
+    : ProjectExplorer::AbstractProcessStep(bsl, bs)
+{
+
+}
+
+bool SnapcraftStep::init(QList<const ProjectExplorer::BuildStep *> &)
+{
+    //QString projectDir = target()->project()->projectDirectory().toString();
+    ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration();
+    if(!bc)
+        return false;
+
+    Utils::FileName snapcraftBin = Utils::FileName::fromString(Constants::UBUNTU_SCRIPTPATH);
+    snapcraftBin = snapcraftBin.appendPath(QString::fromLatin1("run_snapcraft.py"));
+
+    ProjectExplorer::ProcessParameters *param = processParameters();
+    param->setWorkingDirectory(bc->buildDirectory().toUserOutput());
+    param->setCommand(snapcraftBin.toUserOutput());
+    param->setArguments(QString::fromLatin1("-s '%1'").arg(snapcraftBin.toFileInfo().absoluteFilePath()));
+    param->setMacroExpander(bc->macroExpander());
+    param->setEnvironment(bc->environment());
+
+    return true;
+}
+
+ProjectExplorer::BuildStepConfigWidget *SnapcraftStep::createConfigWidget()
+{
+    return new ProjectExplorer::SimpleBuildStepConfigWidget(this);
+}
+
+Utils::FileName SnapcraftStep::snapcraftCommand() const
+{
+    Utils::Environment env = Utils::Environment::systemEnvironment();
+    Utils::FileName fallback = env.searchInPath(QStringLiteral("snapcraft"));
+    if (!target())
+        return fallback;
+
+    Utils::FileName bin = SnapcraftKitInformation::snapcraftPath(target()->kit());
+    if (!bin.exists())
+        return fallback;
+
+    return bin;
+}
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftstep.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftstep.h	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/project/snapcraftstep.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,33 @@
+#ifndef UBUNTU_INTERNAL_SNAPCRAFTSTEP_H
+#define UBUNTU_INTERNAL_SNAPCRAFTSTEP_H
+
+#include <projectexplorer/abstractprocessstep.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class SnapcraftBuildStepFactory;
+class SnapcraftBuildConfigurationFactory;
+
+class SnapcraftStep : public ProjectExplorer::AbstractProcessStep
+{
+    Q_OBJECT
+public:
+    friend class SnapcraftBuildStepFactory;
+    friend class SnapcraftBuildConfigurationFactory;
+
+    // BuildStep interface
+    virtual bool init(QList<const ProjectExplorer::BuildStep *> &earlierSteps) override;
+    virtual ProjectExplorer::BuildStepConfigWidget *createConfigWidget() override;
+
+    Utils::FileName snapcraftCommand () const;
+
+protected:
+    SnapcraftStep(ProjectExplorer::BuildStepList *bsl);
+    SnapcraftStep(ProjectExplorer::BuildStepList *bsl, SnapcraftStep *bs);
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPCRAFTSTEP_H
 
=== added directory 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/settings'
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/settings/snapcraftkitinformation.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/settings/snapcraftkitinformation.cpp	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/settings/snapcraftkitinformation.cpp	2016-10-18 07:57:32 +0000
@@ -0,0 +1,114 @@
+#include "snapcraftkitinformation.h"
+
+#include <projectexplorer/kit.h>
+
+#include <utils/environment.h>
+#include <utils/qtcassert.h>
+#include <utils/pathchooser.h>
+
+#include <QFileInfo>
+
+namespace Ubuntu {
+namespace Internal {
+
+static const char TOOL_ID[] = "SnapcraftProjectManager.SnapcraftKitInformation";
+
+SnapcraftKitInformation::SnapcraftKitInformation()
+{
+    setObjectName(QStringLiteral("SnapcraftKitInformation"));
+    setId(TOOL_ID);
+    setPriority(29000);
+}
+
+Utils::FileName SnapcraftKitInformation::snapcraftPath(const ProjectExplorer::Kit *k)
+{
+    return k->value(TOOL_ID, QVariant::fromValue<Utils::FileName>(Utils::FileName())).value<Utils::FileName>();
+}
+
+void SnapcraftKitInformation::setSnapcraftPath(ProjectExplorer::Kit *k, const Utils::FileName &snapcraft)
+{
+    if (snapcraft.toFileInfo().isExecutable()) {
+        k->setValue(TOOL_ID, QVariant::fromValue<Utils::FileName>(snapcraft));
+    }
+}
+
+QVariant SnapcraftKitInformation::defaultValue(const ProjectExplorer::Kit *) const
+{
+    Utils::Environment env = Utils::Environment::systemEnvironment();
+    return QVariant::fromValue<Utils::FileName>(env.searchInPath(QStringLiteral("snapcraft")));
+}
+
+QList<ProjectExplorer::Task> SnapcraftKitInformation::validate(const ProjectExplorer::Kit *) const
+{
+    return QList<ProjectExplorer::Task>();
+}
+
+ProjectExplorer::KitInformation::ItemList SnapcraftKitInformation::toUserOutput(const ProjectExplorer::Kit *k) const
+{
+    Utils::FileName snap = snapcraftPath(k);
+    return ItemList {
+        qMakePair(tr("Snapcraft"), snap.exists() ? snap.toUserOutput() : tr("Unconfigured"))
+    };
+}
+
+ProjectExplorer::KitConfigWidget *SnapcraftKitInformation::createConfigWidget(ProjectExplorer::Kit *kit) const
+{
+    return new SnapcraftKitInformationWidget(kit, this);
+}
+
+SnapcraftKitInformationWidget::SnapcraftKitInformationWidget(ProjectExplorer::Kit *kit, const ProjectExplorer::KitInformation *ki)
+    : ProjectExplorer::KitConfigWidget(kit, ki)
+    , m_chooser(new Utils::PathChooser)
+    , m_ignoreChange(false)
+{
+    m_chooser->setExpectedKind(Utils::PathChooser::ExistingCommand);
+    m_chooser->setFileName(SnapcraftKitInformation::snapcraftPath(kit));
+    connect(m_chooser, &Utils::PathChooser::pathChanged,
+            this, &SnapcraftKitInformationWidget::pathWasChanged);
+}
+
+SnapcraftKitInformationWidget::~SnapcraftKitInformationWidget()
+{
+    delete m_chooser;
+}
+
+QString SnapcraftKitInformationWidget::displayName() const
+{
+    return tr("Snapcraft");
+}
+
+void SnapcraftKitInformationWidget::makeReadOnly()
+{
+    m_chooser->setReadOnly(true);
+}
+
+void SnapcraftKitInformationWidget::refresh()
+{
+    if (!m_ignoreChange)
+        m_chooser->setPath(SnapcraftKitInformation::snapcraftPath(kit()).toUserOutput());
+}
+
+QWidget *SnapcraftKitInformationWidget::mainWidget() const
+{
+    return m_chooser->lineEdit();
+}
+
+QString SnapcraftKitInformationWidget::toolTip() const
+{
+    return tr("The snapcraft binary to use for this kit.");
+}
+
+QWidget *SnapcraftKitInformationWidget::buttonWidget() const
+{
+    return m_chooser->buttonAtIndex(0);
+}
+
+void SnapcraftKitInformationWidget::pathWasChanged()
+{
+    m_ignoreChange = true;
+    SnapcraftKitInformation::setSnapcraftPath(kit(), m_chooser->fileName());
+    m_ignoreChange = false;
+}
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/settings/snapcraftkitinformation.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/settings/snapcraftkitinformation.h	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/settings/snapcraftkitinformation.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,59 @@
+#ifndef UBUNTU_INTERNAL_SNAPCRAFTKITINFORMATION_H
+#define UBUNTU_INTERNAL_SNAPCRAFTKITINFORMATION_H
+
+#include <projectexplorer/kitconfigwidget.h>
+#include <projectexplorer/kitinformation.h>
+
+namespace Utils {
+class PathChooser;
+}
+
+namespace Ubuntu {
+namespace Internal {
+
+class SnapcraftKitInformation : public ProjectExplorer::KitInformation
+{
+    Q_OBJECT
+public:
+    SnapcraftKitInformation();
+
+    static Utils::FileName snapcraftPath (const ProjectExplorer::Kit *k);
+    static void setSnapcraftPath (ProjectExplorer::Kit *k, const Utils::FileName &snapcraft);
+
+    // KitInformation interface
+    virtual QVariant defaultValue(const ProjectExplorer::Kit *) const override;
+    virtual QList<ProjectExplorer::Task> validate(const ProjectExplorer::Kit *) const override;
+    virtual ItemList toUserOutput(const ProjectExplorer::Kit *) const override;
+    virtual ProjectExplorer::KitConfigWidget *createConfigWidget(ProjectExplorer::Kit *) const override;
+
+private:
+    Utils::FileName m_snapcraftPath;
+};
+
+class SnapcraftKitInformationWidget : public ProjectExplorer::KitConfigWidget
+{
+public:
+    SnapcraftKitInformationWidget(ProjectExplorer::Kit *kit, const ProjectExplorer::KitInformation *ki);
+    virtual ~SnapcraftKitInformationWidget();
+
+    // KitConfigWidget interface
+    virtual QString displayName() const override;
+    virtual void makeReadOnly() override;
+    virtual void refresh() override;
+    virtual QWidget *mainWidget() const override;
+    virtual QString toolTip() const override;
+    virtual QWidget *buttonWidget() const override;
+
+private:
+    void pathWasChanged();
+private:
+    Utils::PathChooser *m_chooser;
+    bool m_ignoreChange;
+
+
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPCRAFTKITINFORMATION_H
 
=== added file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/snap.pri'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/snap.pri	1970-01-01 00:00:00 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/snap/snap.pri	2016-10-18 07:57:32 +0000
@@ -0,0 +1,27 @@
+
+LIBS+=-lyaml-cpp
+
+SOURCES += \
+    $$PWD/project/snapcraftproject.cpp \
+    $$PWD/project/snapcraftprojectfile.cpp \
+    $$PWD/project/snapcraftprojectnode.cpp \
+    $$PWD/project/snapcraftprojectmanager.cpp \
+    $$PWD/project/snapcraftbuildconfigurationfactory.cpp \
+    $$PWD/project/snapcraftbuildconfiguration.cpp \
+    $$PWD/project/snapcraftrsyncstep.cpp \
+    $$PWD/project/snapcraftstep.cpp \
+    $$PWD/project/snapcraftbuildstepfactory.cpp \
+    $$PWD/settings/snapcraftkitinformation.cpp
+
+HEADERS += \
+    $$PWD/project/snapcraftproject.h \
+    $$PWD/project/snapcraftprojectfile.h \
+    $$PWD/project/snapcraftprojectnode.h \
+    $$PWD/project/snapcraftprojectmanager.h \
+    $$PWD/project/snapcraftbuildconfigurationfactory.h \
+    $$PWD/project/snapcraftbuildconfiguration.h \
+    $$PWD/project/snapcraftrsyncstep.h \
+    $$PWD/project/snapcraftstep.h \
+    $$PWD/project/snapcraftbuildstepfactory.h \
+    $$PWD/settings/snapcraftkitinformation.h
+
 
=== modified file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuclicktool.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuclicktool.cpp	2016-08-26 14:14:29 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuclicktool.cpp	2016-10-18 07:57:32 +0000
@@ -471,6 +471,11 @@
     return UbuntuClickTool::findOrCreateToolWrapper(QStringLiteral("make"),target);
 }
 
+Utils::FileName UbuntuClickTool::findOrCreateSnapcraftWrapper(const UbuntuClickTool::Target &target)
+{
+    return Utils::FileName::fromString(UbuntuClickTool::findOrCreateToolWrapper(QStringLiteral("snapcraft"),target));
+}
+
 QString UbuntuClickTool::mapIncludePathsForCMake(const ProjectExplorer::Kit *k, const QString &in)
 {
     if (in.isEmpty())
 
=== modified file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuclicktool.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuclicktool.h	2016-08-26 14:14:29 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuclicktool.h	2016-10-18 07:57:32 +0000
@@ -86,6 +86,7 @@
     static QString findOrCreateToolWrapper(const QString &tool, const UbuntuClickTool::Target &target);
     static QString findOrCreateQMakeWrapper(const UbuntuClickTool::Target &target);
     static QString findOrCreateMakeWrapper(const UbuntuClickTool::Target &target);
+    static Utils::FileName findOrCreateSnapcraftWrapper(const UbuntuClickTool::Target &target);
     static QString mapIncludePathsForCMake(const ProjectExplorer::Kit *k, const QString &in);
     static QString hostArchitecture ();
     static bool    compatibleWithHostArchitecture (const QString &targetArch);
 
=== modified file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuconstants.h'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuconstants.h	2016-09-22 16:11:03 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuconstants.h	2016-10-18 07:57:32 +0000
@@ -393,6 +393,16 @@
 const char CHROOT_UPDATE_LIST_SCRIPT[] = "%1/ubuntu/scripts/qtc_chroot_get_upgrades.py %2 %3";
 
 
+//Snapcraft
+const char SNAPCRAFT_PROJECT_MIMETYPE[]       = "application/x-snapcraft";
+const char SNAPCRAFT_PROJECT_ID[            ] = "SnapcraftProjectManager.SnapcraftProject";
+const char SNAPCRAFT_PROJECT_PROJECTCONTEXT[] = "SnapcraftProject.ProjectContext";
+const char SNAPCRAFT_BUILDCONFIGURATION_ID[]  = "SnapcraftProjectManager.SnapcraftBuildconfiguration.Id";
+const char SNAPCRAFT_RSYNCBUILSSTEP_ID[]      = "SnapcraftProjectManager.SnapcraftRsyncStep.Id";
+const char SNAPCRAFT_BUILDSTEP_ID[]           = "SnapcraftProjectManager.SnapcraftStep.Id";
+
+
+
 } // namespace Ubuntu
 } // namespace Constants
 
 
=== modified file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntukitmanager.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntukitmanager.cpp	2016-08-26 14:14:29 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntukitmanager.cpp	2016-10-18 07:57:32 +0000
@@ -5,7 +5,8 @@
 #include "ubuntuclickdialog.h"
 #include "ubuntuqtversion.h"
 #include "settings.h"
-#include "device/container/containerdevice.h"
+#include <ubuntu/device/container/containerdevice.h>
+#include <ubuntu/snap/settings/snapcraftkitinformation.h>
 
 #include <coreplugin/icore.h>
 #include <projectexplorer/kitmanager.h>
@@ -509,6 +510,8 @@
         ProjectExplorer::SysRootKitInformation::setSysRoot(k,Utils::FileName::fromString(UbuntuClickTool::targetBasePath(tc->clickTarget())));
     }
 
+    SnapcraftKitInformation::setSnapcraftPath(k, UbuntuClickTool::findOrCreateSnapcraftWrapper(tc->clickTarget()));
+
     //make sure we point to a ubuntu device
     Core::Id devId = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(k);
     bool devValid        = devId.isValid(); //invalid type
 
=== modified file 'dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuplugin.cpp'
--- dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuplugin.cpp	2016-09-22 16:11:03 +0000
+++ dist/qtcreator/src/plugins/ubuntu/src/ubuntu/ubuntuplugin.cpp	2016-10-18 07:57:32 +0000
@@ -53,6 +53,11 @@
 #include <ubuntu/wizards/ubuntufirstrunwizard.h>
 #include <ubuntu/wizards/ubuntuprojectmigrationwizard.h>
 
+#include <ubuntu/snap/project/snapcraftprojectmanager.h>
+#include <ubuntu/snap/project/snapcraftbuildconfigurationfactory.h>
+#include <ubuntu/snap/project/snapcraftbuildstepfactory.h>
+#include <ubuntu/snap/settings/snapcraftkitinformation.h>
+
 #include "ubuntujsextension.h"
 
 #include <coreplugin/modemanager.h>
@@ -175,6 +180,13 @@
     addAutoReleasedObject(new UbuntuRemoteRunControlFactory);
     addAutoReleasedObject(new UbuntuLocalRunControlFactory);
 
+
+    addAutoReleasedObject(new SnapcraftProjectManager);
+    addAutoReleasedObject(new SnapcraftBuildConfigurationFactory);
+    addAutoReleasedObject(new SnapcraftBuildStepFactory);
+
+    ProjectExplorer::KitManager::registerKitInformation(new SnapcraftKitInformation);
+
     // Build support
     addAutoReleasedObject(new ClickToolChainFactory);
     addAutoReleasedObject(new UbuntuHtmlBuildConfigurationFactory);
@@ -379,6 +391,7 @@
 
     while (!ok) {
         QProcess proc;
+        qDebug()<<"Running "<<Constants::UBUNTU_TARGET_TOOL;
         proc.setProgram(Constants::UBUNTU_TARGET_TOOL);
 
         QStringList args{QStringLiteral("initialized")};
@@ -407,8 +420,7 @@
                 if (Settings::askForContainerSetup()) {
                     QString text = tr("The container backend is not completely initialized.\n\n"
                                       "Create default configuration?\n"
-                                      "Not setting up the container configuration will\nmake it impossible to run applications locally.\n\n"
-                                      "Note: Will override existing LXD configurations."
+                                      "Not setting up the container configuration will\nmake it impossible to run applications locally."
                                       );
 
                     QMessageBox box(QMessageBox::Question, qApp->applicationName(),text, QMessageBox::Yes | QMessageBox::No | QMessageBox::Abort, Core::ICore::mainWindow());
 
=== added directory 'dist/yaml-cpp'
=== added file 'dist/yaml-cpp/.clang-format'
--- dist/yaml-cpp/.clang-format	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/.clang-format	2016-10-18 07:57:32 +0000
@@ -0,0 +1,47 @@
+---
+# BasedOnStyle:  Google
+AccessModifierOffset: -1
+ConstructorInitializerIndentWidth: 4
+AlignEscapedNewlinesLeft: true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: true
+AlwaysBreakBeforeMultilineStrings: true
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BinPackParameters: true
+ColumnLimit:     80
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+DerivePointerBinding: true
+ExperimentalAutoDetectBinPacking: false
+IndentCaseLabels: true
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 60
+PenaltyBreakString: 1000
+PenaltyBreakFirstLessLess: 120
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerBindsToType: true
+SpacesBeforeTrailingComments: 2
+Cpp11BracedListStyle: true
+Standard:        Auto
+IndentWidth:     2
+TabWidth:        8
+UseTab:          Never
+BreakBeforeBraces: Attach
+IndentFunctionDeclarationAfterType: true
+SpacesInParentheses: false
+SpacesInAngles:  false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpaceAfterControlStatementKeyword: true
+SpaceBeforeAssignmentOperators: true
+ContinuationIndentWidth: 4
+...
+
 
=== added file 'dist/yaml-cpp/.hgeol'
--- dist/yaml-cpp/.hgeol	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/.hgeol	2016-10-18 07:57:32 +0000
@@ -0,0 +1,4 @@
+**.h = native
+**.c = native
+**.cpp = native
+**.txt = native
 
=== added file 'dist/yaml-cpp/.hgignore'
--- dist/yaml-cpp/.hgignore	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/.hgignore	2016-10-18 07:57:32 +0000
@@ -0,0 +1,1 @@
+syntax: glob
 
=== added directory 'dist/yaml-cpp/.pc'
=== added file 'dist/yaml-cpp/.pc/.quilt_patches'
--- dist/yaml-cpp/.pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/.pc/.quilt_patches	2016-10-18 07:57:32 +0000
@@ -0,0 +1,1 @@
+debian/patches
 
=== added file 'dist/yaml-cpp/.pc/.quilt_series'
--- dist/yaml-cpp/.pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/.pc/.quilt_series	2016-10-18 07:57:32 +0000
@@ -0,0 +1,1 @@
+series
 
=== added file 'dist/yaml-cpp/.pc/.version'
--- dist/yaml-cpp/.pc/.version	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/.pc/.version	2016-10-18 07:57:32 +0000
@@ -0,0 +1,1 @@
+2
 
=== added file 'dist/yaml-cpp/.pc/applied-patches'
--- dist/yaml-cpp/.pc/applied-patches	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/.pc/applied-patches	2016-10-18 07:57:32 +0000
@@ -0,0 +1,2 @@
+pkgconfig.patch
+install-cmake-dev-files.patch
 
=== added directory 'dist/yaml-cpp/.pc/install-cmake-dev-files.patch'
=== added file 'dist/yaml-cpp/.pc/install-cmake-dev-files.patch/CMakeLists.txt'
--- dist/yaml-cpp/.pc/install-cmake-dev-files.patch/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/.pc/install-cmake-dev-files.patch/CMakeLists.txt	2016-10-18 07:57:32 +0000
@@ -0,0 +1,340 @@
+###
+### CMake settings
+###
+## Due to Mac OSX we need to keep compatibility with CMake 2.6
+# see http://www.cmake.org/Wiki/CMake_Policies
+cmake_minimum_required(VERSION 2.6)
+# see http://www.cmake.org/cmake/help/cmake-2-8-docs.html#policy:CMP0012
+if(POLICY CMP0012)
+	cmake_policy(SET CMP0012 OLD)
+endif()
+# see http://www.cmake.org/cmake/help/cmake-2-8-docs.html#policy:CMP0015
+if(POLICY CMP0015)
+	cmake_policy(SET CMP0015 OLD)
+endif()
+
+include(CheckCXXCompilerFlag)
+
+
+###
+### Project settings
+###
+project(YAML_CPP)
+
+set(YAML_CPP_VERSION_MAJOR "0")
+set(YAML_CPP_VERSION_MINOR "5")
+set(YAML_CPP_VERSION_PATCH "2")
+set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML_CPP_VERSION_PATCH}")
+
+enable_testing()
+
+
+###
+### Project options
+###
+## Project stuff
+option(YAML_CPP_BUILD_TOOLS "Enable testing and parse tools" ON)
+option(YAML_CPP_BUILD_CONTRIB "Enable contrib stuff in library" ON)
+
+## Build options
+# --> General
+# see http://www.cmake.org/cmake/help/cmake2.6docs.html#variable:BUILD_SHARED_LIBS
+#     http://www.cmake.org/cmake/help/cmake2.6docs.html#command:add_library
+option(BUILD_SHARED_LIBS "Build Shared Libraries" OFF)
+
+# --> Apple
+option(APPLE_UNIVERSAL_BIN "Apple: Build universal binary" OFF)
+
+# --> Microsoft Visual C++
+# see http://msdn.microsoft.com/en-us/library/aa278396(v=VS.60).aspx
+#     http://msdn.microsoft.com/en-us/library/2kzt1wy3(v=VS.71).aspx
+option(MSVC_SHARED_RT "MSVC: Build with shared runtime libs (/MD)" ON)
+option(MSVC_STHREADED_RT "MSVC: Build with single-threaded static runtime libs (/ML until VS .NET 2003)" OFF)
+
+###
+### Sources, headers, directories and libs
+###
+
+# From http://www.cmake.org/pipermail/cmake/2010-March/035992.html:
+# function to collect all the sources from sub-directories
+# into a single list
+function(add_sources)
+  get_property(is_defined GLOBAL PROPERTY SRCS_LIST DEFINED)
+  if(NOT is_defined)
+    define_property(GLOBAL PROPERTY SRCS_LIST
+      BRIEF_DOCS "List of source files"
+      FULL_DOCS "List of all source files in the entire project")
+  endif()
+  # make absolute paths
+  set(SRCS)
+  foreach(s IN LISTS ARGN)
+    if(NOT IS_ABSOLUTE "${s}")
+      get_filename_component(s "${s}" ABSOLUTE)
+    endif()
+    list(APPEND SRCS "${s}")
+  endforeach()
+  # append to global list
+  set_property(GLOBAL APPEND PROPERTY SRCS_LIST "${SRCS}")
+endfunction(add_sources)
+
+set(header_directory "include/yaml-cpp/")
+
+file(GLOB sources "src/[a-zA-Z]*.cpp")
+file(GLOB_RECURSE public_headers "include/yaml-cpp/[a-zA-Z]*.h")
+file(GLOB private_headers "src/[a-zA-Z]*.h")
+
+if(YAML_CPP_BUILD_CONTRIB)
+	file(GLOB contrib_sources "src/contrib/[a-zA-Z]*.cpp")
+	file(GLOB contrib_public_headers "include/yaml-cpp/contrib/[a-zA-Z]*.h")
+	file(GLOB contrib_private_headers "src/contrib/[a-zA-Z]*.h")
+else()
+	add_definitions(-DYAML_CPP_NO_CONTRIB)
+endif()
+
+set(library_sources
+  ${sources}
+  ${public_headers}
+  ${private_headers}
+  ${contrib_sources}
+  ${contrib_public_headers}
+  ${contrib_private_headers}
+)
+add_sources(${library_sources})
+
+if(VERBOSE)
+	message(STATUS "sources: ${sources}")
+	message(STATUS "public_headers: ${public_headers}")
+	message(STATUS "private_headers: ${private_headers}")
+	message(STATUS "contrib_sources: ${contrib_sources}")
+	message(STATUS "contrib_public_headers: ${contrib_public_headers}")
+	message(STATUS "contrib_private_headers: ${contrib_private_headers}")
+endif()
+
+include_directories(${YAML_CPP_SOURCE_DIR}/src)
+include_directories(${YAML_CPP_SOURCE_DIR}/include)
+
+find_package(Boost REQUIRED)
+include_directories(${Boost_INCLUDE_DIRS})
+
+
+###
+### General compilation settings
+###
+set(yaml_c_flags ${CMAKE_C_FLAGS})
+set(yaml_cxx_flags ${CMAKE_CXX_FLAGS})
+
+if(BUILD_SHARED_LIBS)
+	set(LABEL_SUFFIX "shared")
+else()
+	set(LABEL_SUFFIX "static")
+endif()
+
+if(APPLE)
+	if(APPLE_UNIVERSAL_BIN)
+		set(CMAKE_OSX_ARCHITECTURES ppc;i386)
+	endif()
+endif()
+
+if(IPHONE)
+	set(CMAKE_OSX_SYSROOT "iphoneos4.2")
+	set(CMAKE_OSX_ARCHITECTURES "armv6;armv7")
+endif()
+
+if(WIN32)
+	if(BUILD_SHARED_LIBS)
+		add_definitions(-D${PROJECT_NAME}_DLL)	# use or build Windows DLL
+	endif()
+	if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+		set(CMAKE_INSTALL_PREFIX "C:/")
+	endif()
+endif()
+
+# GCC or Clang specialities
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU" OR
+   "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+	### General stuff
+	if(WIN32)
+		set(CMAKE_SHARED_LIBRARY_PREFIX "")	# DLLs do not have a "lib" prefix
+		set(CMAKE_IMPORT_LIBRARY_PREFIX "")	# same for DLL import libs
+		set(CMAKE_LINK_DEF_FILE_FLAG "")	# CMake workaround (2.8.3)
+	endif()
+
+	### Project stuff
+	if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
+		set(CMAKE_BUILD_TYPE Release)
+	endif()
+	#
+	set(CMAKE_CXX_FLAGS_RELEASE "-O2")
+	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
+	set(CMAKE_CXX_FLAGS_DEBUG "-g")
+	set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os")
+	#
+	set(GCC_EXTRA_OPTIONS "")
+	#
+	set(FLAG_TESTED "-Wextra")
+	check_cxx_compiler_flag(${FLAG_TESTED} FLAG_WEXTRA)
+	if(FLAG_WEXTRA)
+		set(GCC_EXTRA_OPTIONS "${GCC_EXTRA_OPTIONS} ${FLAG_TESTED}")
+	endif()
+	#
+	set(yaml_cxx_flags "-Wall ${GCC_EXTRA_OPTIONS} -pedantic -Wno-long-long ${yaml_cxx_flags}")
+
+	### Make specific
+	if(${CMAKE_BUILD_TOOL} MATCHES make OR ${CMAKE_BUILD_TOOL} MATCHES gmake)
+		add_custom_target(debuggable $(MAKE) clean
+			COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Debug ${CMAKE_SOURCE_DIR}
+			COMMENT "Adjusting settings for debug compilation"
+			VERBATIM)
+		add_custom_target(releasable $(MAKE) clean
+			COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Release ${CMAKE_SOURCE_DIR}
+			COMMENT "Adjusting settings for release compilation"
+			VERBATIM)
+	endif()
+endif()
+
+# Microsoft VisualC++ specialities
+if(MSVC)
+	### General stuff
+	# a) Change MSVC runtime library settings (/MD[d], /MT[d], /ML[d] (single-threaded until VS 2003))
+	#    plus set lib suffix for later use and project label accordingly
+	# see http://msdn.microsoft.com/en-us/library/aa278396(v=VS.60).aspx
+	#     http://msdn.microsoft.com/en-us/library/2kzt1wy3(v=VS.71).aspx
+	set(LIB_RT_SUFFIX "md")	# CMake defaults to /MD for MSVC
+	set(LIB_RT_OPTION "/MD")
+	#
+	if(NOT MSVC_SHARED_RT)	# User wants to have static runtime libraries (/MT, /ML)
+		if(MSVC_STHREADED_RT)	# User wants to have old single-threaded static runtime libraries
+			set(LIB_RT_SUFFIX "ml")
+			set(LIB_RT_OPTION "/ML")
+			if(NOT ${MSVC_VERSION} LESS 1400)
+				message(FATAL_ERROR "Single-threaded static runtime libraries (/ML) only available until VS .NET 2003 (7.1).")
+			endif()
+		else()
+			set(LIB_RT_SUFFIX "mt")
+			set(LIB_RT_OPTION "/MT")
+		endif()
+
+		# correct linker options
+		foreach(flag_var  yaml_c_flags  yaml_cxx_flags)
+			foreach(config_name  ""  DEBUG  RELEASE  MINSIZEREL  RELWITHDEBINFO)
+				set(var_name "${flag_var}")
+				if(NOT "${config_name}" STREQUAL "")
+					set(var_name "${var_name}_${config_name}")
+				endif()
+				string(REPLACE "/MD" "${LIB_RT_OPTION}" ${var_name} "${${var_name}}")
+			endforeach()
+		endforeach()
+	endif()
+	#
+	set(LABEL_SUFFIX "${LABEL_SUFFIX} ${LIB_RT_SUFFIX}")
+
+	# b) Change prefix for static libraries
+	set(CMAKE_STATIC_LIBRARY_PREFIX "lib")	# to distinguish static libraries from DLL import libs
+
+	# c) Correct suffixes for static libraries
+	if(NOT BUILD_SHARED_LIBS)
+		### General stuff
+		set(LIB_TARGET_SUFFIX "${LIB_SUFFIX}${LIB_RT_SUFFIX}")
+	endif()
+
+	### Project stuff
+	# /W3 = set warning level; see http://msdn.microsoft.com/en-us/library/thxezb7y.aspx
+	# /wd4127 = disable warning C4127 "conditional expression is constant"; see http://msdn.microsoft.com/en-us/library/6t66728h.aspx
+	# /wd4355 = disable warning C4355 "'this' : used in base member initializer list"; http://msdn.microsoft.com/en-us/library/3c594ae3.aspx
+	set(yaml_cxx_flags "/W3 /wd4127 /wd4355 ${yaml_cxx_flags}")
+endif()
+
+
+###
+### General install settings
+###
+if(WIN32)
+	set(_library_dir bin)	# .dll are in PATH, like executables
+else()
+	set(_library_dir lib)
+endif()
+
+set(INCLUDE_INSTALL_ROOT_DIR include)
+
+set(INCLUDE_INSTALL_DIR ${INCLUDE_INSTALL_ROOT_DIR}/yaml-cpp)
+set(LIB_INSTALL_DIR "${_library_dir}${LIB_SUFFIX}")
+
+set(_INSTALL_DESTINATIONS
+	RUNTIME DESTINATION bin
+	LIBRARY DESTINATION ${LIB_INSTALL_DIR}
+	ARCHIVE DESTINATION "lib${LIB_SUFFIX}"
+)
+
+
+###
+### Library
+###
+add_library(yaml-cpp ${library_sources})
+set_target_properties(yaml-cpp PROPERTIES
+  COMPILE_FLAGS "${yaml_c_flags} ${yaml_cxx_flags}"
+)
+
+set_target_properties(yaml-cpp PROPERTIES
+	VERSION "${YAML_CPP_VERSION}"
+	SOVERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}"
+	PROJECT_LABEL "yaml-cpp ${LABEL_SUFFIX}"
+)
+
+if(IPHONE)
+	set_target_properties(yaml-cpp PROPERTIES
+		XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET "3.0"
+	)
+endif()
+
+if(MSVC)
+	if(NOT BUILD_SHARED_LIBS)
+		# correct library names
+		set_target_properties(yaml-cpp PROPERTIES
+			DEBUG_POSTFIX "${LIB_TARGET_SUFFIX}d"
+			RELEASE_POSTFIX "${LIB_TARGET_SUFFIX}"
+			MINSIZEREL_POSTFIX "${LIB_TARGET_SUFFIX}"
+			RELWITHDEBINFO_POSTFIX "${LIB_TARGET_SUFFIX}"
+		)
+	endif()
+endif()
+
+install(TARGETS yaml-cpp ${_INSTALL_DESTINATIONS})
+install(
+	DIRECTORY ${header_directory}
+	DESTINATION ${INCLUDE_INSTALL_DIR}
+	FILES_MATCHING PATTERN "*.h"
+)
+
+export(
+    TARGETS yaml-cpp
+    FILE "${PROJECT_BINARY_DIR}/yaml-cpp-targets.cmake")
+export(PACKAGE yaml-cpp)
+set(EXPORT_TARGETS yaml-cpp CACHE INTERNAL "export targets")
+
+set(CONFIG_INCLUDE_DIRS "${YAML_CPP_SOURCE_DIR}/include")
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config.cmake.in
+	"${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake" @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config-version.cmake.in
+	"${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake" @ONLY)
+
+if(UNIX)
+	set(PC_FILE ${CMAKE_BINARY_DIR}/yaml-cpp.pc)
+	configure_file("yaml-cpp.pc.cmake" ${PC_FILE} @ONLY)
+	install(FILES ${PC_FILE} DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
+endif()
+
+
+###
+### Extras
+###
+if(YAML_CPP_BUILD_TOOLS)
+	add_subdirectory(test)
+	add_subdirectory(util)
+endif()
+
+### Formatting
+get_property(all_sources GLOBAL PROPERTY SRCS_LIST)
+add_custom_target(format
+	COMMAND clang-format --style=file -i ${all_sources}
+	COMMENT "Running clang-format"
+	VERBATIM)
 
=== added directory 'dist/yaml-cpp/.pc/pkgconfig.patch'
=== added file 'dist/yaml-cpp/.pc/pkgconfig.patch/yaml-cpp.pc.cmake'
--- dist/yaml-cpp/.pc/pkgconfig.patch/yaml-cpp.pc.cmake	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/.pc/pkgconfig.patch/yaml-cpp.pc.cmake	2016-10-18 07:57:32 +0000
@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=${prefix}/@LIB_INSTALL_DIR@
+includedir=${prefix}/@INCLUDE_INSTALL_ROOT_DIR@
+
+Name: Yaml-cpp
+Description: A YAML parser and emitter for C++
+Version: @YAML_CPP_VERSION@
+Requires:
+Libs: -L${libdir} -lyaml-cpp
+Cflags: -I${includedir}
 
=== added file 'dist/yaml-cpp/CMakeLists.txt'
--- dist/yaml-cpp/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/CMakeLists.txt	2016-10-18 07:57:32 +0000
@@ -0,0 +1,356 @@
+###
+### CMake settings
+###
+## Due to Mac OSX we need to keep compatibility with CMake 2.6
+# see http://www.cmake.org/Wiki/CMake_Policies
+cmake_minimum_required(VERSION 2.6)
+# see http://www.cmake.org/cmake/help/cmake-2-8-docs.html#policy:CMP0012
+if(POLICY CMP0012)
+	cmake_policy(SET CMP0012 OLD)
+endif()
+# see http://www.cmake.org/cmake/help/cmake-2-8-docs.html#policy:CMP0015
+if(POLICY CMP0015)
+	cmake_policy(SET CMP0015 OLD)
+endif()
+
+include(CheckCXXCompilerFlag)
+
+
+###
+### Project settings
+###
+project(YAML_CPP)
+
+set(YAML_CPP_VERSION_MAJOR "0")
+set(YAML_CPP_VERSION_MINOR "5")
+set(YAML_CPP_VERSION_PATCH "2")
+set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML_CPP_VERSION_PATCH}")
+
+enable_testing()
+
+
+###
+### Project options
+###
+## Project stuff
+option(YAML_CPP_BUILD_TOOLS "Enable testing and parse tools" ON)
+option(YAML_CPP_BUILD_CONTRIB "Enable contrib stuff in library" ON)
+
+## Build options
+# --> General
+# see http://www.cmake.org/cmake/help/cmake2.6docs.html#variable:BUILD_SHARED_LIBS
+#     http://www.cmake.org/cmake/help/cmake2.6docs.html#command:add_library
+option(BUILD_SHARED_LIBS "Build Shared Libraries" OFF)
+
+# --> Apple
+option(APPLE_UNIVERSAL_BIN "Apple: Build universal binary" OFF)
+
+# --> Microsoft Visual C++
+# see http://msdn.microsoft.com/en-us/library/aa278396(v=VS.60).aspx
+#     http://msdn.microsoft.com/en-us/library/2kzt1wy3(v=VS.71).aspx
+option(MSVC_SHARED_RT "MSVC: Build with shared runtime libs (/MD)" ON)
+option(MSVC_STHREADED_RT "MSVC: Build with single-threaded static runtime libs (/ML until VS .NET 2003)" OFF)
+
+###
+### Sources, headers, directories and libs
+###
+
+# From http://www.cmake.org/pipermail/cmake/2010-March/035992.html:
+# function to collect all the sources from sub-directories
+# into a single list
+function(add_sources)
+  get_property(is_defined GLOBAL PROPERTY SRCS_LIST DEFINED)
+  if(NOT is_defined)
+    define_property(GLOBAL PROPERTY SRCS_LIST
+      BRIEF_DOCS "List of source files"
+      FULL_DOCS "List of all source files in the entire project")
+  endif()
+  # make absolute paths
+  set(SRCS)
+  foreach(s IN LISTS ARGN)
+    if(NOT IS_ABSOLUTE "${s}")
+      get_filename_component(s "${s}" ABSOLUTE)
+    endif()
+    list(APPEND SRCS "${s}")
+  endforeach()
+  # append to global list
+  set_property(GLOBAL APPEND PROPERTY SRCS_LIST "${SRCS}")
+endfunction(add_sources)
+
+set(header_directory "include/yaml-cpp/")
+
+file(GLOB sources "src/[a-zA-Z]*.cpp")
+file(GLOB_RECURSE public_headers "include/yaml-cpp/[a-zA-Z]*.h")
+file(GLOB private_headers "src/[a-zA-Z]*.h")
+
+if(YAML_CPP_BUILD_CONTRIB)
+	file(GLOB contrib_sources "src/contrib/[a-zA-Z]*.cpp")
+	file(GLOB contrib_public_headers "include/yaml-cpp/contrib/[a-zA-Z]*.h")
+	file(GLOB contrib_private_headers "src/contrib/[a-zA-Z]*.h")
+else()
+	add_definitions(-DYAML_CPP_NO_CONTRIB)
+endif()
+
+set(library_sources
+  ${sources}
+  ${public_headers}
+  ${private_headers}
+  ${contrib_sources}
+  ${contrib_public_headers}
+  ${contrib_private_headers}
+)
+add_sources(${library_sources})
+
+if(VERBOSE)
+	message(STATUS "sources: ${sources}")
+	message(STATUS "public_headers: ${public_headers}")
+	message(STATUS "private_headers: ${private_headers}")
+	message(STATUS "contrib_sources: ${contrib_sources}")
+	message(STATUS "contrib_public_headers: ${contrib_public_headers}")
+	message(STATUS "contrib_private_headers: ${contrib_private_headers}")
+endif()
+
+include_directories(${YAML_CPP_SOURCE_DIR}/src)
+include_directories(${YAML_CPP_SOURCE_DIR}/include)
+
+find_package(Boost REQUIRED)
+include_directories(${Boost_INCLUDE_DIRS})
+
+
+###
+### General compilation settings
+###
+set(yaml_c_flags ${CMAKE_C_FLAGS})
+set(yaml_cxx_flags ${CMAKE_CXX_FLAGS})
+
+if(BUILD_SHARED_LIBS)
+	set(LABEL_SUFFIX "shared")
+else()
+	set(LABEL_SUFFIX "static")
+endif()
+
+if(APPLE)
+	if(APPLE_UNIVERSAL_BIN)
+		set(CMAKE_OSX_ARCHITECTURES ppc;i386)
+	endif()
+endif()
+
+if(IPHONE)
+	set(CMAKE_OSX_SYSROOT "iphoneos4.2")
+	set(CMAKE_OSX_ARCHITECTURES "armv6;armv7")
+endif()
+
+if(WIN32)
+	if(BUILD_SHARED_LIBS)
+		add_definitions(-D${PROJECT_NAME}_DLL)	# use or build Windows DLL
+	endif()
+	if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+		set(CMAKE_INSTALL_PREFIX "C:/")
+	endif()
+endif()
+
+# GCC or Clang specialities
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU" OR
+   "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+	### General stuff
+	if(WIN32)
+		set(CMAKE_SHARED_LIBRARY_PREFIX "")	# DLLs do not have a "lib" prefix
+		set(CMAKE_IMPORT_LIBRARY_PREFIX "")	# same for DLL import libs
+		set(CMAKE_LINK_DEF_FILE_FLAG "")	# CMake workaround (2.8.3)
+	endif()
+
+	### Project stuff
+	if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
+		set(CMAKE_BUILD_TYPE Release)
+	endif()
+	#
+	set(CMAKE_CXX_FLAGS_RELEASE "-O2")
+	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
+	set(CMAKE_CXX_FLAGS_DEBUG "-g")
+	set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os")
+	#
+	set(GCC_EXTRA_OPTIONS "")
+	#
+	set(FLAG_TESTED "-Wextra")
+	check_cxx_compiler_flag(${FLAG_TESTED} FLAG_WEXTRA)
+	if(FLAG_WEXTRA)
+		set(GCC_EXTRA_OPTIONS "${GCC_EXTRA_OPTIONS} ${FLAG_TESTED}")
+	endif()
+	#
+	set(yaml_cxx_flags "-Wall ${GCC_EXTRA_OPTIONS} -pedantic -Wno-long-long ${yaml_cxx_flags}")
+
+	### Make specific
+	if(${CMAKE_BUILD_TOOL} MATCHES make OR ${CMAKE_BUILD_TOOL} MATCHES gmake)
+		add_custom_target(debuggable $(MAKE) clean
+			COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Debug ${CMAKE_SOURCE_DIR}
+			COMMENT "Adjusting settings for debug compilation"
+			VERBATIM)
+		add_custom_target(releasable $(MAKE) clean
+			COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Release ${CMAKE_SOURCE_DIR}
+			COMMENT "Adjusting settings for release compilation"
+			VERBATIM)
+	endif()
+endif()
+
+# Microsoft VisualC++ specialities
+if(MSVC)
+	### General stuff
+	# a) Change MSVC runtime library settings (/MD[d], /MT[d], /ML[d] (single-threaded until VS 2003))
+	#    plus set lib suffix for later use and project label accordingly
+	# see http://msdn.microsoft.com/en-us/library/aa278396(v=VS.60).aspx
+	#     http://msdn.microsoft.com/en-us/library/2kzt1wy3(v=VS.71).aspx
+	set(LIB_RT_SUFFIX "md")	# CMake defaults to /MD for MSVC
+	set(LIB_RT_OPTION "/MD")
+	#
+	if(NOT MSVC_SHARED_RT)	# User wants to have static runtime libraries (/MT, /ML)
+		if(MSVC_STHREADED_RT)	# User wants to have old single-threaded static runtime libraries
+			set(LIB_RT_SUFFIX "ml")
+			set(LIB_RT_OPTION "/ML")
+			if(NOT ${MSVC_VERSION} LESS 1400)
+				message(FATAL_ERROR "Single-threaded static runtime libraries (/ML) only available until VS .NET 2003 (7.1).")
+			endif()
+		else()
+			set(LIB_RT_SUFFIX "mt")
+			set(LIB_RT_OPTION "/MT")
+		endif()
+
+		# correct linker options
+		foreach(flag_var  yaml_c_flags  yaml_cxx_flags)
+			foreach(config_name  ""  DEBUG  RELEASE  MINSIZEREL  RELWITHDEBINFO)
+				set(var_name "${flag_var}")
+				if(NOT "${config_name}" STREQUAL "")
+					set(var_name "${var_name}_${config_name}")
+				endif()
+				string(REPLACE "/MD" "${LIB_RT_OPTION}" ${var_name} "${${var_name}}")
+			endforeach()
+		endforeach()
+	endif()
+	#
+	set(LABEL_SUFFIX "${LABEL_SUFFIX} ${LIB_RT_SUFFIX}")
+
+	# b) Change prefix for static libraries
+	set(CMAKE_STATIC_LIBRARY_PREFIX "lib")	# to distinguish static libraries from DLL import libs
+
+	# c) Correct suffixes for static libraries
+	if(NOT BUILD_SHARED_LIBS)
+		### General stuff
+		set(LIB_TARGET_SUFFIX "${LIB_SUFFIX}${LIB_RT_SUFFIX}")
+	endif()
+
+	### Project stuff
+	# /W3 = set warning level; see http://msdn.microsoft.com/en-us/library/thxezb7y.aspx
+	# /wd4127 = disable warning C4127 "conditional expression is constant"; see http://msdn.microsoft.com/en-us/library/6t66728h.aspx
+	# /wd4355 = disable warning C4355 "'this' : used in base member initializer list"; http://msdn.microsoft.com/en-us/library/3c594ae3.aspx
+	set(yaml_cxx_flags "/W3 /wd4127 /wd4355 ${yaml_cxx_flags}")
+endif()
+
+
+###
+### General install settings
+###
+if(WIN32)
+	set(_library_dir bin)	# .dll are in PATH, like executables
+else()
+	set(_library_dir ${CMAKE_INSTALL_PREFIX}/lib)
+endif()
+
+set(INCLUDE_INSTALL_ROOT_DIR include)
+
+set(INCLUDE_INSTALL_DIR ${INCLUDE_INSTALL_ROOT_DIR}/yaml-cpp)
+SET(LIB_INSTALL_DIR "${_library_dir}${LIB_SUFFIX}" CACHE
+    "Directory relative to CMAKE_INSTALL_PREFIX in which to install libraries"
+    STRING)
+MARK_AS_ADVANCED(LIB_INSTALL_DIR)
+
+set(_INSTALL_DESTINATIONS
+	RUNTIME DESTINATION bin
+	LIBRARY DESTINATION ${LIB_INSTALL_DIR}
+	ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
+)
+
+
+###
+### Library
+###
+add_library(yaml-cpp ${library_sources})
+set_target_properties(yaml-cpp PROPERTIES
+  COMPILE_FLAGS "${yaml_c_flags} ${yaml_cxx_flags}"
+)
+
+set_target_properties(yaml-cpp PROPERTIES
+	VERSION "${YAML_CPP_VERSION}"
+	SOVERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}"
+	PROJECT_LABEL "yaml-cpp ${LABEL_SUFFIX}"
+)
+
+if(IPHONE)
+	set_target_properties(yaml-cpp PROPERTIES
+		XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET "3.0"
+	)
+endif()
+
+if(MSVC)
+	if(NOT BUILD_SHARED_LIBS)
+		# correct library names
+		set_target_properties(yaml-cpp PROPERTIES
+			DEBUG_POSTFIX "${LIB_TARGET_SUFFIX}d"
+			RELEASE_POSTFIX "${LIB_TARGET_SUFFIX}"
+			MINSIZEREL_POSTFIX "${LIB_TARGET_SUFFIX}"
+			RELWITHDEBINFO_POSTFIX "${LIB_TARGET_SUFFIX}"
+		)
+	endif()
+endif()
+
+install(TARGETS yaml-cpp EXPORT yaml-cpp-targets ${_INSTALL_DESTINATIONS})
+install(
+	DIRECTORY ${header_directory}
+	DESTINATION ${INCLUDE_INSTALL_DIR}
+	FILES_MATCHING PATTERN "*.h"
+)
+
+export(
+    TARGETS yaml-cpp
+    FILE "${PROJECT_BINARY_DIR}/yaml-cpp-targets.cmake")
+export(PACKAGE yaml-cpp)
+set(EXPORT_TARGETS yaml-cpp CACHE INTERNAL "export targets")
+
+set(CONFIG_INCLUDE_DIRS "${YAML_CPP_SOURCE_DIR}/include")
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config.cmake.in
+	"${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake" @ONLY)
+
+set(INSTALL_CMAKE_DIR ${LIB_INSTALL_DIR}/cmake/yaml-cpp)
+file(RELATIVE_PATH REL_INCLUDE_DIR "${INSTALL_CMAKE_DIR}" "${CMAKE_INSTALL_PREFIX}/include")
+set(CONFIG_INCLUDE_DIRS "\${YAML_CPP_CMAKE_DIR}/${REL_INCLUDE_DIR}")
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config.cmake.in
+	"${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/yaml-cpp-config.cmake" @ONLY)
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config-version.cmake.in
+	"${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake" @ONLY)
+
+install(FILES
+	"${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/yaml-cpp-config.cmake"
+	"${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake"
+	DESTINATION "${INSTALL_CMAKE_DIR}" COMPONENT dev)
+install(EXPORT yaml-cpp-targets DESTINATION ${INSTALL_CMAKE_DIR})
+
+if(UNIX)
+	set(PC_FILE ${CMAKE_BINARY_DIR}/yaml-cpp.pc)
+	configure_file("yaml-cpp.pc.cmake" ${PC_FILE} @ONLY)
+	install(FILES ${PC_FILE} DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
+endif()
+
+
+###
+### Extras
+###
+if(YAML_CPP_BUILD_TOOLS)
+	add_subdirectory(test)
+	add_subdirectory(util)
+endif()
+
+### Formatting
+get_property(all_sources GLOBAL PROPERTY SRCS_LIST)
+add_custom_target(format
+	COMMAND clang-format --style=file -i ${all_sources}
+	COMMENT "Running clang-format"
+	VERBATIM)
 
=== added directory 'dist/yaml-cpp/debian'
=== added file 'dist/yaml-cpp/debian/changelog'
--- dist/yaml-cpp/debian/changelog	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/changelog	2016-10-18 07:57:32 +0000
@@ -0,0 +1,56 @@
+yaml-cpp (0.5.2-3) unstable; urgency=medium
+
+  * Fix error in yaml-cpp-config.cmake
+  * Disable gtest's use of pthread on hurd and kfreebsd
+
+ -- Paul Novotny <[e-mail]>  Mon, 30 Nov 2015 16:53:57 -0500
+
+yaml-cpp (0.5.2-2) unstable; urgency=medium
+
+  * Rename libyaml-cpp0.5 to libyaml-cpp0.5v5 for gcc5 transition
+    (Closes: #791317)
+
+ -- Paul Novotny <[e-mail]>  Tue, 04 Aug 2015 18:03:35 -0400
+
+yaml-cpp (0.5.2-1) unstable; urgency=medium
+
+  * Update due to yaml-cpp from Google Code to GitHub
+  * Imported Upstream version 0.5.2
+  * Remove patches/fix-unit-test.patch, applied upstream
+  * Remove patches/remove-conflicting-google-libs.patch, applied upstream
+
+ -- Paul Novotny <[e-mail]>  Thu, 23 Apr 2015 16:40:20 -0400
+
+yaml-cpp (0.5.1+hg20150210-1) experimental; urgency=medium
+
+  [ Andreas Tille ]
+  * Import latest upstream
+  * Fix failing unit tests
+  * Inject package into collab-maint to enable more people contributing
+  * cme fix dpkg-control
+  * debhelper 9
+  
+  [ Paul Novotny ]
+  * Add myself as Uploader
+  * Import latest upstream VCS status
+  * Fix failing unit tests, update version number
+  * Install cmake development files
+
+ -- Andreas Tille <[e-mail]>  Mon, 09 Feb 2015 13:36:42 +0100
+
+yaml-cpp (0.5.1-1) unstable; urgency=low
+
+  * New upstream release. (Closes: #706708)
+  * Bump Standards-Version to 3.9.4.
+  * libyaml-cpp-dev: remove multiarch path in yaml-cpp.pc to make
+    lintian happy.
+  * debian/copyright: new Format URI.
+  * debian/control: remove Vcs-Svn field.
+
+ -- Lifeng Sun <[e-mail]>  Fri, 30 Aug 2013 18:29:05 +0800
+
+yaml-cpp (0.3.0-1) unstable; urgency=low
+
+  * Initial release (Closes: #636985)
+
+ -- Lifeng Sun <[e-mail]>  Sun, 03 Jun 2012 23:48:30 +0800
 
=== added file 'dist/yaml-cpp/debian/compat'
--- dist/yaml-cpp/debian/compat	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/compat	2016-10-18 07:57:32 +0000
@@ -0,0 +1,1 @@
+9
 
=== added file 'dist/yaml-cpp/debian/control'
--- dist/yaml-cpp/debian/control	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/control	2016-10-18 07:57:32 +0000
@@ -0,0 +1,39 @@
+Source: yaml-cpp
+Maintainer: Lifeng Sun <[e-mail]>
+Uploaders: Andreas Tille <[e-mail]>,
+           Paul Novotny <[e-mail]>
+Section: devel
+Priority: optional
+Build-Depends: debhelper (>= 9),
+               cmake,
+               libboost-dev
+Standards-Version: 3.9.6
+Vcs-Browser: https://anonscm.debian.org/cgit/collab-maint/yaml-cpp.git
+Vcs-Git: git://anonscm.debian.org/collab-maint/yaml-cpp.git
+Homepage: https://github.com/jbeder/yaml-cpp
+
+Package: libyaml-cpp0.5v5
+Architecture: any
+Multi-Arch: same
+Section: libs
+Depends: ${shlibs:Depends},
+         ${misc:Depends}
+Pre-Depends: ${misc:Pre-Depends}
+Conflicts: libyaml-cpp0.5
+Replaces: libyaml-cpp0.5
+Description: YAML parser and emitter for C++
+ yaml-cpp is a C++ library for parsing and emitting data in YAML 1.2, a
+ human-readable data serialization format.
+ .
+ This package provides run-time library of yaml-cpp.
+
+Package: libyaml-cpp-dev
+Architecture: any
+Section: libdevel
+Depends: libyaml-cpp0.5v5 (= ${binary:Version}),
+         ${misc:Depends}
+Description: YAML parser and emitter for C++ - development files
+ yaml-cpp is a C++ library for parsing and emitting data in YAML 1.2, a
+ human-readable data serialization format.
+ .
+ This package provides development files of yaml-cpp.
 
=== added file 'dist/yaml-cpp/debian/copyright'
--- dist/yaml-cpp/debian/copyright	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/copyright	2016-10-18 07:57:32 +0000
@@ -0,0 +1,44 @@
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: yaml-cpp
+Source: https://github.com/jbeder/yaml-cpp
+
+Files: *
+Copyright: 2008 Jesse Beder <[e-mail]>
+License: X11
+ Permission is hereby granted, free of charge, to any person obtaining a
+ copy of this software and associated documentation files (the "Software"),
+ to deal in the Software without restriction, including without limitation
+ the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ and/or sell copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following conditions:
+ .
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+ .
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+
+Files: debian/*
+Copyright: 2011-2013 Lifeng Sun <[e-mail]>
+License: GPL-2.0+
+ This package is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ .
+ This package is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ .
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>
+ .
+ On Debian systems, the complete text of the GNU General
+ Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".
+
 
=== added file 'dist/yaml-cpp/debian/libyaml-cpp-dev.install'
--- dist/yaml-cpp/debian/libyaml-cpp-dev.install	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/libyaml-cpp-dev.install	2016-10-18 07:57:32 +0000
@@ -0,0 +1,5 @@
+usr/include/
+usr/lib/*/*.a
+usr/lib/*/*.so
+usr/lib/*/pkgconfig/
+usr/lib/*/cmake/
 
=== added file 'dist/yaml-cpp/debian/libyaml-cpp0.5v5.install'
--- dist/yaml-cpp/debian/libyaml-cpp0.5v5.install	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/libyaml-cpp0.5v5.install	2016-10-18 07:57:32 +0000
@@ -0,0 +1,1 @@
+usr/lib/*/libyaml-cpp.so.*
 
=== added directory 'dist/yaml-cpp/debian/patches'
=== added file 'dist/yaml-cpp/debian/patches/install-cmake-dev-files.patch'
--- dist/yaml-cpp/debian/patches/install-cmake-dev-files.patch	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/patches/install-cmake-dev-files.patch	2016-10-18 07:57:32 +0000
@@ -0,0 +1,69 @@
+Description: Install libs and cmake files to the Debian location
+ Instead of moving the libs to the DEB_HOST_MULTIARCH lib directory during
+ packaging, have cmake install the libs directly. This is needed so the CMake
+ development files point to the correct location for the libs. Also, install
+ yaml-cpp-config.cmake, yaml-cpp-config-version.cmake, and
+ yaml-cpp-targets.cmake.
+Author: Paul Novotny <[e-mail]>
+Forwarded: not-needed
+Last-Update: 2015-11-29
+
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -251,18 +251,21 @@
+ if(WIN32)
+ 	set(_library_dir bin)	# .dll are in PATH, like executables
+ else()
+-	set(_library_dir lib)
++	set(_library_dir ${CMAKE_INSTALL_PREFIX}/lib)
+ endif()
+ 
+ set(INCLUDE_INSTALL_ROOT_DIR include)
+ 
+ set(INCLUDE_INSTALL_DIR ${INCLUDE_INSTALL_ROOT_DIR}/yaml-cpp)
+-set(LIB_INSTALL_DIR "${_library_dir}${LIB_SUFFIX}")
++SET(LIB_INSTALL_DIR "${_library_dir}${LIB_SUFFIX}" CACHE
++    "Directory relative to CMAKE_INSTALL_PREFIX in which to install libraries"
++    STRING)
++MARK_AS_ADVANCED(LIB_INSTALL_DIR)
+ 
+ set(_INSTALL_DESTINATIONS
+ 	RUNTIME DESTINATION bin
+ 	LIBRARY DESTINATION ${LIB_INSTALL_DIR}
+-	ARCHIVE DESTINATION "lib${LIB_SUFFIX}"
++	ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
+ )
+ 
+ 
+@@ -298,7 +301,7 @@
+ 	endif()
+ endif()
+ 
+-install(TARGETS yaml-cpp ${_INSTALL_DESTINATIONS})
++install(TARGETS yaml-cpp EXPORT yaml-cpp-targets ${_INSTALL_DESTINATIONS})
+ install(
+ 	DIRECTORY ${header_directory}
+ 	DESTINATION ${INCLUDE_INSTALL_DIR}
+@@ -314,9 +317,22 @@
+ set(CONFIG_INCLUDE_DIRS "${YAML_CPP_SOURCE_DIR}/include")
+ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config.cmake.in
+ 	"${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake" @ONLY)
++
++set(INSTALL_CMAKE_DIR ${LIB_INSTALL_DIR}/cmake/yaml-cpp)
++file(RELATIVE_PATH REL_INCLUDE_DIR "${INSTALL_CMAKE_DIR}" "${CMAKE_INSTALL_PREFIX}/include")
++set(CONFIG_INCLUDE_DIRS "\${YAML_CPP_CMAKE_DIR}/${REL_INCLUDE_DIR}")
++configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config.cmake.in
++	"${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/yaml-cpp-config.cmake" @ONLY)
++
+ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp-config-version.cmake.in
+ 	"${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake" @ONLY)
+ 
++install(FILES
++	"${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/yaml-cpp-config.cmake"
++	"${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake"
++	DESTINATION "${INSTALL_CMAKE_DIR}" COMPONENT dev)
++install(EXPORT yaml-cpp-targets DESTINATION ${INSTALL_CMAKE_DIR})
++
+ if(UNIX)
+ 	set(PC_FILE ${CMAKE_BINARY_DIR}/yaml-cpp.pc)
+ 	configure_file("yaml-cpp.pc.cmake" ${PC_FILE} @ONLY)
 
=== added file 'dist/yaml-cpp/debian/patches/pkgconfig.patch'
--- dist/yaml-cpp/debian/patches/pkgconfig.patch	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/patches/pkgconfig.patch	2016-10-18 07:57:32 +0000
@@ -0,0 +1,19 @@
+Author: Lifeng Sun <[e-mail]>
+Last-Update: Fri, 30 Aug 2013 18:29:05 +0800
+Description: remove multiarch path in yaml-cpp.pc
+
+--- a/yaml-cpp.pc.cmake
++++ b/yaml-cpp.pc.cmake
+@@ -1,11 +1,10 @@
+ prefix=@CMAKE_INSTALL_PREFIX@
+ exec_prefix=@CMAKE_INSTALL_PREFIX@
+-libdir=${prefix}/@LIB_INSTALL_DIR@
+ includedir=${prefix}/@INCLUDE_INSTALL_ROOT_DIR@
+ 
+ Name: Yaml-cpp
+ Description: A YAML parser and emitter for C++
+ Version: @YAML_CPP_VERSION@
+ Requires:
+-Libs: -L${libdir} -lyaml-cpp
++Libs: -lyaml-cpp
+ Cflags: -I${includedir}
 
=== added file 'dist/yaml-cpp/debian/patches/series'
--- dist/yaml-cpp/debian/patches/series	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/patches/series	2016-10-18 07:57:32 +0000
@@ -0,0 +1,2 @@
+pkgconfig.patch
+install-cmake-dev-files.patch
 
=== added file 'dist/yaml-cpp/debian/rules'
--- dist/yaml-cpp/debian/rules	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/rules	2016-10-18 07:57:32 +0000
@@ -0,0 +1,64 @@
+#!/usr/bin/make -f
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+# This has to be exported to make some magic below work.
+export DH_OPTIONS
+
+DEB_HOST_MULTIARCH ?= $(shell dpkg-architecture -qDEB_HOST_MULTIARCH)
+
+CPPFLAGS :=$(shell dpkg-buildflags --get CPPFLAGS)
+CFLAGS   :=$(shell dpkg-buildflags --get CFLAGS)
+CXXFLAGS :=$(shell dpkg-buildflags --get CXXFLAGS)
+LDFLAGS  :=$(shell dpkg-buildflags --get LDFLAGS)
+
+export DEB_HOST_MULTIARCH CPPFLAGS CFLAGS CXXFLAGS LDFLAGS
+
+ifeq (,$(filter $(DEB_BUILD_ARCH),kfreebsd-amd64 kfreebsd-i386 hurd-i386))
+    DISABLE_PTHREADS=OFF
+else
+    DISABLE_PTHREADS=ON
+endif
+
+override_dh_auto_configure:
+	dh_testdir
+	mkdir build-static; cd build-static; \
+		cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
+				 -DLIB_INSTALL_DIR=/usr/lib/$(DEB_HOST_MULTIARCH) \
+				 -DYAML_CPP_BUILD_TOOLS=ON \
+				 -Dgtest_disable_pthreads=$(DISABLE_PTHREADS)
+	mkdir build-shared; cd build-shared; \
+		cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
+				 -DLIB_INSTALL_DIR=/usr/lib/$(DEB_HOST_MULTIARCH) \
+				 -DBUILD_SHARED_LIBS=ON \
+				 -DYAML_CPP_BUILD_TOOLS=ON \
+				 -Dgtest_disable_pthreads=$(DISABLE_PTHREADS)
+
+override_dh_auto_build:
+	dh_testdir
+	$(MAKE) -C build-static
+	$(MAKE) -C build-shared
+	# It might make sense to also provide the utils in a separate package
+	# $(MAKE) -C build-shared util
+
+override_dh_auto_install:
+	dh_testdir
+	dh_prep
+	$(MAKE) -C build-static install DESTDIR=$(CURDIR)/debian/tmp
+	$(MAKE) -C build-shared install DESTDIR=$(CURDIR)/debian/tmp
+
+override_dh_auto_test:
+	$(MAKE) -C build-static test
+	$(MAKE) -C build-shared test
+
+clean:
+	dh_testdir
+	dh_auto_clean
+	dh_clean
+	rm -rf build-static build-shared
+
+%:
+	dh $@
+
+.PHONY: clean
 
=== added directory 'dist/yaml-cpp/debian/source'
=== added file 'dist/yaml-cpp/debian/source/format'
--- dist/yaml-cpp/debian/source/format	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/source/format	2016-10-18 07:57:32 +0000
@@ -0,0 +1,1 @@
+3.0 (quilt)
 
=== added file 'dist/yaml-cpp/debian/watch'
--- dist/yaml-cpp/debian/watch	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/debian/watch	2016-10-18 07:57:32 +0000
@@ -0,0 +1,3 @@
+version=3
+opts=filenamemangle=s/.+\/release-?(\d\S*)\.tar\.gz/yaml-cpp-$1\.tar\.gz/ \
+  https://github.com/jbeder/yaml-cpp/releases .*/release-?(\d\S*)\.tar\.gz
 
=== added directory 'dist/yaml-cpp/include'
=== added directory 'dist/yaml-cpp/include/yaml-cpp'
=== added file 'dist/yaml-cpp/include/yaml-cpp/anchor.h'
--- dist/yaml-cpp/include/yaml-cpp/anchor.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/anchor.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,17 @@
+#ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+
+namespace YAML {
+typedef std::size_t anchor_t;
+const anchor_t NullAnchor = 0;
+}
+
+#endif  // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/binary.h'
--- dist/yaml-cpp/include/yaml-cpp/binary.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/binary.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,67 @@
+#ifndef BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+YAML_CPP_API std::string EncodeBase64(const unsigned char *data,
+                                      std::size_t size);
+YAML_CPP_API std::vector<unsigned char> DecodeBase64(const std::string &input);
+
+class YAML_CPP_API Binary {
+ public:
+  Binary() : m_unownedData(0), m_unownedSize(0) {}
+  Binary(const unsigned char *data_, std::size_t size_)
+      : m_unownedData(data_), m_unownedSize(size_) {}
+
+  bool owned() const { return !m_unownedData; }
+  std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; }
+  const unsigned char *data() const {
+    return owned() ? &m_data[0] : m_unownedData;
+  }
+
+  void swap(std::vector<unsigned char> &rhs) {
+    if (m_unownedData) {
+      m_data.swap(rhs);
+      rhs.clear();
+      rhs.resize(m_unownedSize);
+      std::copy(m_unownedData, m_unownedData + m_unownedSize, rhs.begin());
+      m_unownedData = 0;
+      m_unownedSize = 0;
+    } else {
+      m_data.swap(rhs);
+    }
+  }
+
+  bool operator==(const Binary &rhs) const {
+    const std::size_t s = size();
+    if (s != rhs.size())
+      return false;
+    const unsigned char *d1 = data();
+    const unsigned char *d2 = rhs.data();
+    for (std::size_t i = 0; i < s; i++) {
+      if (*d1++ != *d2++)
+        return false;
+    }
+    return true;
+  }
+
+  bool operator!=(const Binary &rhs) const { return !(*this == rhs); }
+
+ private:
+  std::vector<unsigned char> m_data;
+  const unsigned char *m_unownedData;
+  std::size_t m_unownedSize;
+};
+}
+
+#endif  // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added directory 'dist/yaml-cpp/include/yaml-cpp/contrib'
=== added file 'dist/yaml-cpp/include/yaml-cpp/contrib/anchordict.h'
--- dist/yaml-cpp/include/yaml-cpp/contrib/anchordict.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/contrib/anchordict.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,37 @@
+#ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <vector>
+
+#include "../anchor.h"
+
+namespace YAML {
+/// AnchorDict
+/// . An object that stores and retrieves values correlating to anchor_t
+///   values.
+/// . Efficient implementation that can make assumptions about how anchor_t
+///   values are assigned by the Parser class.
+template <class T>
+class AnchorDict {
+ public:
+  void Register(anchor_t anchor, T value) {
+    if (anchor > m_data.size()) {
+      m_data.resize(anchor);
+    }
+    m_data[anchor - 1] = value;
+  }
+
+  T Get(anchor_t anchor) const { return m_data[anchor - 1]; }
+
+ private:
+  std::vector<T> m_data;
+};
+}
+
+#endif  // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/contrib/graphbuilder.h'
--- dist/yaml-cpp/include/yaml-cpp/contrib/graphbuilder.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/contrib/graphbuilder.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,147 @@
+#ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/mark.h"
+#include <string>
+
+namespace YAML {
+class Parser;
+
+// GraphBuilderInterface
+// . Abstraction of node creation
+// . pParentNode is always NULL or the return value of one of the NewXXX()
+//   functions.
+class GraphBuilderInterface {
+ public:
+  // Create and return a new node with a null value.
+  virtual void *NewNull(const Mark &mark, void *pParentNode) = 0;
+
+  // Create and return a new node with the given tag and value.
+  virtual void *NewScalar(const Mark &mark, const std::string &tag,
+                          void *pParentNode, const std::string &value) = 0;
+
+  // Create and return a new sequence node
+  virtual void *NewSequence(const Mark &mark, const std::string &tag,
+                            void *pParentNode) = 0;
+
+  // Add pNode to pSequence.  pNode was created with one of the NewXxx()
+  // functions and pSequence with NewSequence().
+  virtual void AppendToSequence(void *pSequence, void *pNode) = 0;
+
+  // Note that no moew entries will be added to pSequence
+  virtual void SequenceComplete(void *pSequence) { (void)pSequence; }
+
+  // Create and return a new map node
+  virtual void *NewMap(const Mark &mark, const std::string &tag,
+                       void *pParentNode) = 0;
+
+  // Add the pKeyNode => pValueNode mapping to pMap.  pKeyNode and pValueNode
+  // were created with one of the NewXxx() methods and pMap with NewMap().
+  virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) = 0;
+
+  // Note that no more assignments will be made in pMap
+  virtual void MapComplete(void *pMap) { (void)pMap; }
+
+  // Return the node that should be used in place of an alias referencing
+  // pNode (pNode by default)
+  virtual void *AnchorReference(const Mark &mark, void *pNode) {
+    (void)mark;
+    return pNode;
+  }
+};
+
+// Typesafe wrapper for GraphBuilderInterface.  Assumes that Impl defines
+// Node, Sequence, and Map types.  Sequence and Map must derive from Node
+// (unless Node is defined as void).  Impl must also implement function with
+// all of the same names as the virtual functions in GraphBuilderInterface
+// -- including the ones with default implementations -- but with the
+// prototypes changed to accept an explicit Node*, Sequence*, or Map* where
+// appropriate.
+template <class Impl>
+class GraphBuilder : public GraphBuilderInterface {
+ public:
+  typedef typename Impl::Node Node;
+  typedef typename Impl::Sequence Sequence;
+  typedef typename Impl::Map Map;
+
+  GraphBuilder(Impl &impl) : m_impl(impl) {
+    Map *pMap = NULL;
+    Sequence *pSeq = NULL;
+    Node *pNode = NULL;
+
+    // Type consistency checks
+    pNode = pMap;
+    pNode = pSeq;
+  }
+
+  GraphBuilderInterface &AsBuilderInterface() { return *this; }
+
+  virtual void *NewNull(const Mark &mark, void *pParentNode) {
+    return CheckType<Node>(m_impl.NewNull(mark, AsNode(pParentNode)));
+  }
+
+  virtual void *NewScalar(const Mark &mark, const std::string &tag,
+                          void *pParentNode, const std::string &value) {
+    return CheckType<Node>(
+        m_impl.NewScalar(mark, tag, AsNode(pParentNode), value));
+  }
+
+  virtual void *NewSequence(const Mark &mark, const std::string &tag,
+                            void *pParentNode) {
+    return CheckType<Sequence>(
+        m_impl.NewSequence(mark, tag, AsNode(pParentNode)));
+  }
+  virtual void AppendToSequence(void *pSequence, void *pNode) {
+    m_impl.AppendToSequence(AsSequence(pSequence), AsNode(pNode));
+  }
+  virtual void SequenceComplete(void *pSequence) {
+    m_impl.SequenceComplete(AsSequence(pSequence));
+  }
+
+  virtual void *NewMap(const Mark &mark, const std::string &tag,
+                       void *pParentNode) {
+    return CheckType<Map>(m_impl.NewMap(mark, tag, AsNode(pParentNode)));
+  }
+  virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) {
+    m_impl.AssignInMap(AsMap(pMap), AsNode(pKeyNode), AsNode(pValueNode));
+  }
+  virtual void MapComplete(void *pMap) { m_impl.MapComplete(AsMap(pMap)); }
+
+  virtual void *AnchorReference(const Mark &mark, void *pNode) {
+    return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode)));
+  }
+
+ private:
+  Impl &m_impl;
+
+  // Static check for pointer to T
+  template <class T, class U>
+  static T *CheckType(U *p) {
+    return p;
+  }
+
+  static Node *AsNode(void *pNode) { return static_cast<Node *>(pNode); }
+  static Sequence *AsSequence(void *pSeq) {
+    return static_cast<Sequence *>(pSeq);
+  }
+  static Map *AsMap(void *pMap) { return static_cast<Map *>(pMap); }
+};
+
+void *BuildGraphOfNextDocument(Parser &parser,
+                               GraphBuilderInterface &graphBuilder);
+
+template <class Impl>
+typename Impl::Node *BuildGraphOfNextDocument(Parser &parser, Impl &impl) {
+  GraphBuilder<Impl> graphBuilder(impl);
+  return static_cast<typename Impl::Node *>(
+      BuildGraphOfNextDocument(parser, graphBuilder));
+}
+}
+
+#endif  // GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/dll.h'
--- dist/yaml-cpp/include/yaml-cpp/dll.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/dll.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,37 @@
+#ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+// The following ifdef block is the standard way of creating macros which make
+// exporting
+// from a DLL simpler. All files within this DLL are compiled with the
+// yaml_cpp_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any
+// project
+// that uses this DLL. This way any other project whose source files include
+// this file see
+// YAML_CPP_API functions as being imported from a DLL, whereas this DLL sees
+// symbols
+// defined with this macro as being exported.
+#undef YAML_CPP_API
+
+#ifdef YAML_CPP_DLL      // Using or Building YAML-CPP DLL (definition defined
+                         // manually)
+#ifdef yaml_cpp_EXPORTS  // Building YAML-CPP DLL (definition created by CMake
+                         // or defined manually)
+//	#pragma message( "Defining YAML_CPP_API for DLL export" )
+#define YAML_CPP_API __declspec(dllexport)
+#else  // yaml_cpp_EXPORTS
+//	#pragma message( "Defining YAML_CPP_API for DLL import" )
+#define YAML_CPP_API __declspec(dllimport)
+#endif  // yaml_cpp_EXPORTS
+#else   // YAML_CPP_DLL
+#define YAML_CPP_API
+#endif  // YAML_CPP_DLL
+
+#endif  // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/emitfromevents.h'
--- dist/yaml-cpp/include/yaml-cpp/emitfromevents.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/emitfromevents.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,57 @@
+#ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <stack>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+
+namespace YAML {
+struct Mark;
+}  // namespace YAML
+
+namespace YAML {
+class Emitter;
+
+class EmitFromEvents : public EventHandler {
+ public:
+  EmitFromEvents(Emitter& emitter);
+
+  virtual void OnDocumentStart(const Mark& mark);
+  virtual void OnDocumentEnd();
+
+  virtual void OnNull(const Mark& mark, anchor_t anchor);
+  virtual void OnAlias(const Mark& mark, anchor_t anchor);
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value);
+
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor, EmitterStyle::value style);
+  virtual void OnSequenceEnd();
+
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style);
+  virtual void OnMapEnd();
+
+ private:
+  void BeginNode();
+  void EmitProps(const std::string& tag, anchor_t anchor);
+
+ private:
+  Emitter& m_emitter;
+
+  struct State {
+    enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue };
+  };
+  std::stack<State::value> m_stateStack;
+};
+}
+
+#endif  // EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/emitter.h'
--- dist/yaml-cpp/include/yaml-cpp/emitter.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/emitter.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,254 @@
+#ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+#include <memory>
+#include <sstream>
+#include <string>
+
+#include "yaml-cpp/binary.h"
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/emitterdef.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/noncopyable.h"
+#include "yaml-cpp/null.h"
+#include "yaml-cpp/ostream_wrapper.h"
+
+namespace YAML {
+class Binary;
+struct _Null;
+}  // namespace YAML
+
+namespace YAML {
+class EmitterState;
+
+class YAML_CPP_API Emitter : private noncopyable {
+ public:
+  Emitter();
+  explicit Emitter(std::ostream& stream);
+  ~Emitter();
+
+  // output
+  const char* c_str() const;
+  std::size_t size() const;
+
+  // state checking
+  bool good() const;
+  const std::string GetLastError() const;
+
+  // global setters
+  bool SetOutputCharset(EMITTER_MANIP value);
+  bool SetStringFormat(EMITTER_MANIP value);
+  bool SetBoolFormat(EMITTER_MANIP value);
+  bool SetIntBase(EMITTER_MANIP value);
+  bool SetSeqFormat(EMITTER_MANIP value);
+  bool SetMapFormat(EMITTER_MANIP value);
+  bool SetIndent(std::size_t n);
+  bool SetPreCommentIndent(std::size_t n);
+  bool SetPostCommentIndent(std::size_t n);
+  bool SetFloatPrecision(std::size_t n);
+  bool SetDoublePrecision(std::size_t n);
+
+  // local setters
+  Emitter& SetLocalValue(EMITTER_MANIP value);
+  Emitter& SetLocalIndent(const _Indent& indent);
+  Emitter& SetLocalPrecision(const _Precision& precision);
+
+  // overloads of write
+  Emitter& Write(const std::string& str);
+  Emitter& Write(bool b);
+  Emitter& Write(char ch);
+  Emitter& Write(const _Alias& alias);
+  Emitter& Write(const _Anchor& anchor);
+  Emitter& Write(const _Tag& tag);
+  Emitter& Write(const _Comment& comment);
+  Emitter& Write(const _Null& n);
+  Emitter& Write(const Binary& binary);
+
+  template <typename T>
+  Emitter& WriteIntegralType(T value);
+
+  template <typename T>
+  Emitter& WriteStreamable(T value);
+
+ private:
+  template <typename T>
+  void SetStreamablePrecision(std::stringstream&) {}
+  std::size_t GetFloatPrecision() const;
+  std::size_t GetDoublePrecision() const;
+
+  void PrepareIntegralStream(std::stringstream& stream) const;
+  void StartedScalar();
+
+ private:
+  void EmitBeginDoc();
+  void EmitEndDoc();
+  void EmitBeginSeq();
+  void EmitEndSeq();
+  void EmitBeginMap();
+  void EmitEndMap();
+  void EmitNewline();
+  void EmitKindTag();
+  void EmitTag(bool verbatim, const _Tag& tag);
+
+  void PrepareNode(EmitterNodeType::value child);
+  void PrepareTopNode(EmitterNodeType::value child);
+  void FlowSeqPrepareNode(EmitterNodeType::value child);
+  void BlockSeqPrepareNode(EmitterNodeType::value child);
+
+  void FlowMapPrepareNode(EmitterNodeType::value child);
+
+  void FlowMapPrepareLongKey(EmitterNodeType::value child);
+  void FlowMapPrepareLongKeyValue(EmitterNodeType::value child);
+  void FlowMapPrepareSimpleKey(EmitterNodeType::value child);
+  void FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child);
+
+  void BlockMapPrepareNode(EmitterNodeType::value child);
+
+  void BlockMapPrepareLongKey(EmitterNodeType::value child);
+  void BlockMapPrepareLongKeyValue(EmitterNodeType::value child);
+  void BlockMapPrepareSimpleKey(EmitterNodeType::value child);
+  void BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child);
+
+  void SpaceOrIndentTo(bool requireSpace, std::size_t indent);
+
+  const char* ComputeFullBoolName(bool b) const;
+  bool CanEmitNewline() const;
+
+ private:
+  std::auto_ptr<EmitterState> m_pState;
+  ostream_wrapper m_stream;
+};
+
+template <typename T>
+inline Emitter& Emitter::WriteIntegralType(T value) {
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::Scalar);
+
+  std::stringstream stream;
+  PrepareIntegralStream(stream);
+  stream << value;
+  m_stream << stream.str();
+
+  StartedScalar();
+
+  return *this;
+}
+
+template <typename T>
+inline Emitter& Emitter::WriteStreamable(T value) {
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::Scalar);
+
+  std::stringstream stream;
+  SetStreamablePrecision<T>(stream);
+  stream << value;
+  m_stream << stream.str();
+
+  StartedScalar();
+
+  return *this;
+}
+
+template <>
+inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream) {
+  stream.precision(GetFloatPrecision());
+}
+
+template <>
+inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream) {
+  stream.precision(GetDoublePrecision());
+}
+
+// overloads of insertion
+inline Emitter& operator<<(Emitter& emitter, const std::string& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, bool v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, char v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned char v) {
+  return emitter.Write(static_cast<char>(v));
+}
+inline Emitter& operator<<(Emitter& emitter, const _Alias& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Anchor& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Tag& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Comment& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Null& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const Binary& b) {
+  return emitter.Write(b);
+}
+
+inline Emitter& operator<<(Emitter& emitter, const char* v) {
+  return emitter.Write(std::string(v));
+}
+
+inline Emitter& operator<<(Emitter& emitter, int v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned int v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, short v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned short v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, long long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned long long v) {
+  return emitter.WriteIntegralType(v);
+}
+
+inline Emitter& operator<<(Emitter& emitter, float v) {
+  return emitter.WriteStreamable(v);
+}
+inline Emitter& operator<<(Emitter& emitter, double v) {
+  return emitter.WriteStreamable(v);
+}
+
+inline Emitter& operator<<(Emitter& emitter, EMITTER_MANIP value) {
+  return emitter.SetLocalValue(value);
+}
+
+inline Emitter& operator<<(Emitter& emitter, _Indent indent) {
+  return emitter.SetLocalIndent(indent);
+}
+
+inline Emitter& operator<<(Emitter& emitter, _Precision precision) {
+  return emitter.SetLocalPrecision(precision);
+}
+}
+
+#endif  // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/emitterdef.h'
--- dist/yaml-cpp/include/yaml-cpp/emitterdef.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/emitterdef.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,16 @@
+#ifndef EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+struct EmitterNodeType {
+  enum value { NoType, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap };
+};
+}
+
+#endif  // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/emittermanip.h'
--- dist/yaml-cpp/include/yaml-cpp/emittermanip.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/emittermanip.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,137 @@
+#ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+namespace YAML {
+enum EMITTER_MANIP {
+  // general manipulators
+  Auto,
+  TagByKind,
+  Newline,
+
+  // output character set
+  EmitNonAscii,
+  EscapeNonAscii,
+
+  // string manipulators
+  // Auto, // duplicate
+  SingleQuoted,
+  DoubleQuoted,
+  Literal,
+
+  // bool manipulators
+  YesNoBool,      // yes, no
+  TrueFalseBool,  // true, false
+  OnOffBool,      // on, off
+  UpperCase,      // TRUE, N
+  LowerCase,      // f, yes
+  CamelCase,      // No, Off
+  LongBool,       // yes, On
+  ShortBool,      // y, t
+
+  // int manipulators
+  Dec,
+  Hex,
+  Oct,
+
+  // document manipulators
+  BeginDoc,
+  EndDoc,
+
+  // sequence manipulators
+  BeginSeq,
+  EndSeq,
+  Flow,
+  Block,
+
+  // map manipulators
+  BeginMap,
+  EndMap,
+  Key,
+  Value,
+  // Flow, // duplicate
+  // Block, // duplicate
+  // Auto, // duplicate
+  LongKey
+};
+
+struct _Indent {
+  _Indent(int value_) : value(value_) {}
+  int value;
+};
+
+inline _Indent Indent(int value) { return _Indent(value); }
+
+struct _Alias {
+  _Alias(const std::string& content_) : content(content_) {}
+  std::string content;
+};
+
+inline _Alias Alias(const std::string content) { return _Alias(content); }
+
+struct _Anchor {
+  _Anchor(const std::string& content_) : content(content_) {}
+  std::string content;
+};
+
+inline _Anchor Anchor(const std::string content) { return _Anchor(content); }
+
+struct _Tag {
+  struct Type {
+    enum value { Verbatim, PrimaryHandle, NamedHandle };
+  };
+
+  explicit _Tag(const std::string& prefix_, const std::string& content_,
+                Type::value type_)
+      : prefix(prefix_), content(content_), type(type_) {}
+  std::string prefix;
+  std::string content;
+  Type::value type;
+};
+
+inline _Tag VerbatimTag(const std::string content) {
+  return _Tag("", content, _Tag::Type::Verbatim);
+}
+
+inline _Tag LocalTag(const std::string content) {
+  return _Tag("", content, _Tag::Type::PrimaryHandle);
+}
+
+inline _Tag LocalTag(const std::string& prefix, const std::string content) {
+  return _Tag(prefix, content, _Tag::Type::NamedHandle);
+}
+
+inline _Tag SecondaryTag(const std::string content) {
+  return _Tag("", content, _Tag::Type::NamedHandle);
+}
+
+struct _Comment {
+  _Comment(const std::string& content_) : content(content_) {}
+  std::string content;
+};
+
+inline _Comment Comment(const std::string content) { return _Comment(content); }
+
+struct _Precision {
+  _Precision(int floatPrecision_, int doublePrecision_)
+      : floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {}
+
+  int floatPrecision;
+  int doublePrecision;
+};
+
+inline _Precision FloatPrecision(int n) { return _Precision(n, -1); }
+
+inline _Precision DoublePrecision(int n) { return _Precision(-1, n); }
+
+inline _Precision Precision(int n) { return _Precision(n, n); }
+}
+
+#endif  // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/emitterstyle.h'
--- dist/yaml-cpp/include/yaml-cpp/emitterstyle.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/emitterstyle.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,16 @@
+#ifndef EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+struct EmitterStyle {
+  enum value { Default, Block, Flow };
+};
+}
+
+#endif  // EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/eventhandler.h'
--- dist/yaml-cpp/include/yaml-cpp/eventhandler.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/eventhandler.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,40 @@
+#ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/emitterstyle.h"
+
+namespace YAML {
+struct Mark;
+
+class EventHandler {
+ public:
+  virtual ~EventHandler() {}
+
+  virtual void OnDocumentStart(const Mark& mark) = 0;
+  virtual void OnDocumentEnd() = 0;
+
+  virtual void OnNull(const Mark& mark, anchor_t anchor) = 0;
+  virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0;
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value) = 0;
+
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor, EmitterStyle::value style) = 0;
+  virtual void OnSequenceEnd() = 0;
+
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style) = 0;
+  virtual void OnMapEnd() = 0;
+};
+}
+
+#endif  // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/exceptions.h'
--- dist/yaml-cpp/include/yaml-cpp/exceptions.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/exceptions.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,227 @@
+#ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/traits.h"
+#include <stdexcept>
+#include <string>
+#include <sstream>
+
+namespace YAML {
+// error messages
+namespace ErrorMsg {
+const char* const YAML_DIRECTIVE_ARGS =
+    "YAML directives must have exactly one argument";
+const char* const YAML_VERSION = "bad YAML version: ";
+const char* const YAML_MAJOR_VERSION = "YAML major version too large";
+const char* const REPEATED_YAML_DIRECTIVE = "repeated YAML directive";
+const char* const TAG_DIRECTIVE_ARGS =
+    "TAG directives must have exactly two arguments";
+const char* const REPEATED_TAG_DIRECTIVE = "repeated TAG directive";
+const char* const CHAR_IN_TAG_HANDLE =
+    "illegal character found while scanning tag handle";
+const char* const TAG_WITH_NO_SUFFIX = "tag handle with no suffix";
+const char* const END_OF_VERBATIM_TAG = "end of verbatim tag not found";
+const char* const END_OF_MAP = "end of map not found";
+const char* const END_OF_MAP_FLOW = "end of map flow not found";
+const char* const END_OF_SEQ = "end of sequence not found";
+const char* const END_OF_SEQ_FLOW = "end of sequence flow not found";
+const char* const MULTIPLE_TAGS =
+    "cannot assign multiple tags to the same node";
+const char* const MULTIPLE_ANCHORS =
+    "cannot assign multiple anchors to the same node";
+const char* const MULTIPLE_ALIASES =
+    "cannot assign multiple aliases to the same node";
+const char* const ALIAS_CONTENT =
+    "aliases can't have any content, *including* tags";
+const char* const INVALID_HEX = "bad character found while scanning hex number";
+const char* const INVALID_UNICODE = "invalid unicode: ";
+const char* const INVALID_ESCAPE = "unknown escape character: ";
+const char* const UNKNOWN_TOKEN = "unknown token";
+const char* const DOC_IN_SCALAR = "illegal document indicator in scalar";
+const char* const EOF_IN_SCALAR = "illegal EOF in scalar";
+const char* const CHAR_IN_SCALAR = "illegal character in scalar";
+const char* const TAB_IN_INDENTATION =
+    "illegal tab when looking for indentation";
+const char* const FLOW_END = "illegal flow end";
+const char* const BLOCK_ENTRY = "illegal block entry";
+const char* const MAP_KEY = "illegal map key";
+const char* const MAP_VALUE = "illegal map value";
+const char* const ALIAS_NOT_FOUND = "alias not found after *";
+const char* const ANCHOR_NOT_FOUND = "anchor not found after &";
+const char* const CHAR_IN_ALIAS =
+    "illegal character found while scanning alias";
+const char* const CHAR_IN_ANCHOR =
+    "illegal character found while scanning anchor";
+const char* const ZERO_INDENT_IN_BLOCK =
+    "cannot set zero indentation for a block scalar";
+const char* const CHAR_IN_BLOCK = "unexpected character in block scalar";
+const char* const AMBIGUOUS_ANCHOR =
+    "cannot assign the same alias to multiple nodes";
+const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined";
+
+const char* const INVALID_NODE =
+    "invalid node; this may result from using a map iterator as a sequence "
+    "iterator, or vice-versa";
+const char* const INVALID_SCALAR = "invalid scalar";
+const char* const KEY_NOT_FOUND = "key not found";
+const char* const BAD_CONVERSION = "bad conversion";
+const char* const BAD_DEREFERENCE = "bad dereference";
+const char* const BAD_SUBSCRIPT = "operator[] call on a scalar";
+const char* const BAD_PUSHBACK = "appending to a non-sequence";
+const char* const BAD_INSERT = "inserting in a non-convertible-to-map";
+
+const char* const UNMATCHED_GROUP_TAG = "unmatched group tag";
+const char* const UNEXPECTED_END_SEQ = "unexpected end sequence token";
+const char* const UNEXPECTED_END_MAP = "unexpected end map token";
+const char* const SINGLE_QUOTED_CHAR =
+    "invalid character in single-quoted string";
+const char* const INVALID_ANCHOR = "invalid anchor";
+const char* const INVALID_ALIAS = "invalid alias";
+const char* const INVALID_TAG = "invalid tag";
+const char* const BAD_FILE = "bad file";
+
+template <typename T>
+inline const std::string KEY_NOT_FOUND_WITH_KEY(
+    const T&, typename disable_if<is_numeric<T> >::type* = 0) {
+  return KEY_NOT_FOUND;
+}
+
+inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) {
+  std::stringstream stream;
+  stream << KEY_NOT_FOUND << ": " << key;
+  return stream.str();
+}
+
+template <typename T>
+inline const std::string KEY_NOT_FOUND_WITH_KEY(
+    const T& key, typename enable_if<is_numeric<T> >::type* = 0) {
+  std::stringstream stream;
+  stream << KEY_NOT_FOUND << ": " << key;
+  return stream.str();
+}
+}
+
+class Exception : public std::runtime_error {
+ public:
+  Exception(const Mark& mark_, const std::string& msg_)
+      : std::runtime_error(build_what(mark_, msg_)), mark(mark_), msg(msg_) {}
+  virtual ~Exception() throw() {}
+
+  Mark mark;
+  std::string msg;
+
+ private:
+  static const std::string build_what(const Mark& mark,
+                                      const std::string& msg) {
+    std::stringstream output;
+    output << "yaml-cpp: error at line " << mark.line + 1 << ", column "
+           << mark.column + 1 << ": " << msg;
+    return output.str();
+  }
+};
+
+class ParserException : public Exception {
+ public:
+  ParserException(const Mark& mark_, const std::string& msg_)
+      : Exception(mark_, msg_) {}
+};
+
+class RepresentationException : public Exception {
+ public:
+  RepresentationException(const Mark& mark_, const std::string& msg_)
+      : Exception(mark_, msg_) {}
+};
+
+// representation exceptions
+class InvalidScalar : public RepresentationException {
+ public:
+  InvalidScalar(const Mark& mark_)
+      : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
+};
+
+class KeyNotFound : public RepresentationException {
+ public:
+  template <typename T>
+  KeyNotFound(const Mark& mark_, const T& key_)
+      : RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {
+  }
+};
+
+template <typename T>
+class TypedKeyNotFound : public KeyNotFound {
+ public:
+  TypedKeyNotFound(const Mark& mark_, const T& key_)
+      : KeyNotFound(mark_, key_), key(key_) {}
+  virtual ~TypedKeyNotFound() throw() {}
+
+  T key;
+};
+
+template <typename T>
+inline TypedKeyNotFound<T> MakeTypedKeyNotFound(const Mark& mark,
+                                                const T& key) {
+  return TypedKeyNotFound<T>(mark, key);
+}
+
+class InvalidNode : public RepresentationException {
+ public:
+  InvalidNode()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {}
+};
+
+class BadConversion : public RepresentationException {
+ public:
+  BadConversion()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_CONVERSION) {}
+};
+
+template <typename T>
+class TypedBadConversion : public BadConversion {
+ public:
+  TypedBadConversion() : BadConversion() {}
+};
+
+class BadDereference : public RepresentationException {
+ public:
+  BadDereference()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {}
+};
+
+class BadSubscript : public RepresentationException {
+ public:
+  BadSubscript()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
+};
+
+class BadPushback : public RepresentationException {
+ public:
+  BadPushback()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {}
+};
+
+class BadInsert : public RepresentationException {
+ public:
+  BadInsert()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {}
+};
+
+class EmitterException : public Exception {
+ public:
+  EmitterException(const std::string& msg_)
+      : Exception(Mark::null_mark(), msg_) {}
+};
+
+class BadFile : public Exception {
+ public:
+  BadFile() : Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {}
+};
+}
+
+#endif  // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/mark.h'
--- dist/yaml-cpp/include/yaml-cpp/mark.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/mark.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,27 @@
+#ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+struct YAML_CPP_API Mark {
+  Mark() : pos(0), line(0), column(0) {}
+
+  static const Mark null_mark() { return Mark(-1, -1, -1); }
+
+  int pos;
+  int line, column;
+
+ private:
+  Mark(int pos_, int line_, int column_)
+      : pos(pos_), line(line_), column(column_) {}
+};
+}
+
+#endif  // MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added directory 'dist/yaml-cpp/include/yaml-cpp/node'
=== added file 'dist/yaml-cpp/include/yaml-cpp/node/convert.h'
--- dist/yaml-cpp/include/yaml-cpp/node/convert.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/node/convert.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,286 @@
+#ifndef NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <limits>
+#include <list>
+#include <map>
+#include <sstream>
+#include <vector>
+
+#include "yaml-cpp/binary.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/type.h"
+#include "yaml-cpp/null.h"
+
+namespace YAML {
+class Binary;
+struct _Null;
+template <typename T>
+struct convert;
+}  // namespace YAML
+
+namespace YAML {
+namespace conversion {
+inline bool IsInfinity(const std::string& input) {
+  return input == ".inf" || input == ".Inf" || input == ".INF" ||
+         input == "+.inf" || input == "+.Inf" || input == "+.INF";
+}
+
+inline bool IsNegativeInfinity(const std::string& input) {
+  return input == "-.inf" || input == "-.Inf" || input == "-.INF";
+}
+
+inline bool IsNaN(const std::string& input) {
+  return input == ".nan" || input == ".NaN" || input == ".NAN";
+}
+}
+
+// std::string
+template <>
+struct convert<std::string> {
+  static Node encode(const std::string& rhs) { return Node(rhs); }
+
+  static bool decode(const Node& node, std::string& rhs) {
+    if (!node.IsScalar())
+      return false;
+    rhs = node.Scalar();
+    return true;
+  }
+};
+
+// C-strings can only be encoded
+template <>
+struct convert<const char*> {
+  static Node encode(const char*& rhs) { return Node(rhs); }
+};
+
+template <std::size_t N>
+struct convert<const char[N]> {
+  static Node encode(const char(&rhs)[N]) { return Node(rhs); }
+};
+
+template <>
+struct convert<_Null> {
+  static Node encode(const _Null& /* rhs */) { return Node(); }
+
+  static bool decode(const Node& node, _Null& /* rhs */) {
+    return node.IsNull();
+  }
+};
+
+#define YAML_DEFINE_CONVERT_STREAMABLE(type, negative_op)                \
+  template <>                                                            \
+  struct convert<type> {                                                 \
+    static Node encode(const type& rhs) {                                \
+      std::stringstream stream;                                          \
+      stream.precision(std::numeric_limits<type>::digits10 + 1);         \
+      stream << rhs;                                                     \
+      return Node(stream.str());                                         \
+    }                                                                    \
+                                                                         \
+    static bool decode(const Node& node, type& rhs) {                    \
+      if (node.Type() != NodeType::Scalar)                               \
+        return false;                                                    \
+      const std::string& input = node.Scalar();                          \
+      std::stringstream stream(input);                                   \
+      stream.unsetf(std::ios::dec);                                      \
+      if ((stream >> std::noskipws >> rhs) && (stream >> std::ws).eof()) \
+        return true;                                                     \
+      if (std::numeric_limits<type>::has_infinity) {                     \
+        if (conversion::IsInfinity(input)) {                             \
+          rhs = std::numeric_limits<type>::infinity();                   \
+          return true;                                                   \
+        } else if (conversion::IsNegativeInfinity(input)) {              \
+          rhs = negative_op std::numeric_limits<type>::infinity();       \
+          return true;                                                   \
+        }                                                                \
+      }                                                                  \
+                                                                         \
+      if (std::numeric_limits<type>::has_quiet_NaN &&                    \
+          conversion::IsNaN(input)) {                                    \
+        rhs = std::numeric_limits<type>::quiet_NaN();                    \
+        return true;                                                     \
+      }                                                                  \
+                                                                         \
+      return false;                                                      \
+    }                                                                    \
+  }
+
+#define YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(type) \
+  YAML_DEFINE_CONVERT_STREAMABLE(type, -)
+
+#define YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(type) \
+  YAML_DEFINE_CONVERT_STREAMABLE(type, +)
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(int);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(short);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long long);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned short);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long long);
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(char);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(signed char);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned char);
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(float);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(double);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long double);
+
+#undef YAML_DEFINE_CONVERT_STREAMABLE_SIGNED
+#undef YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED
+#undef YAML_DEFINE_CONVERT_STREAMABLE
+
+// bool
+template <>
+struct convert<bool> {
+  static Node encode(bool rhs) { return rhs ? Node("true") : Node("false"); }
+
+  YAML_CPP_API static bool decode(const Node& node, bool& rhs);
+};
+
+// std::map
+template <typename K, typename V>
+struct convert<std::map<K, V> > {
+  static Node encode(const std::map<K, V>& rhs) {
+    Node node(NodeType::Map);
+    for (typename std::map<K, V>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.force_insert(it->first, it->second);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::map<K, V>& rhs) {
+    if (!node.IsMap())
+      return false;
+
+    rhs.clear();
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs[it->first.template as<K>()] = it->second.template as<V>();
+#else
+      rhs[it->first.as<K>()] = it->second.as<V>();
+#endif
+    return true;
+  }
+};
+
+// std::vector
+template <typename T>
+struct convert<std::vector<T> > {
+  static Node encode(const std::vector<T>& rhs) {
+    Node node(NodeType::Sequence);
+    for (typename std::vector<T>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.push_back(*it);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::vector<T>& rhs) {
+    if (!node.IsSequence())
+      return false;
+
+    rhs.clear();
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs.push_back(it->template as<T>());
+#else
+      rhs.push_back(it->as<T>());
+#endif
+    return true;
+  }
+};
+
+// std::list
+template <typename T>
+struct convert<std::list<T> > {
+  static Node encode(const std::list<T>& rhs) {
+    Node node(NodeType::Sequence);
+    for (typename std::list<T>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.push_back(*it);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::list<T>& rhs) {
+    if (!node.IsSequence())
+      return false;
+
+    rhs.clear();
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs.push_back(it->template as<T>());
+#else
+      rhs.push_back(it->as<T>());
+#endif
+    return true;
+  }
+};
+
+// std::pair
+template <typename T, typename U>
+struct convert<std::pair<T, U> > {
+  static Node encode(const std::pair<T, U>& rhs) {
+    Node node(NodeType::Sequence);
+    node.push_back(rhs.first);
+    node.push_back(rhs.second);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::pair<T, U>& rhs) {
+    if (!node.IsSequence())
+      return false;
+    if (node.size() != 2)
+      return false;
+
+#if defined(__GNUC__) && __GNUC__ < 4
+    // workaround for GCC 3:
+    rhs.first = node[0].template as<T>();
+#else
+    rhs.first = node[0].as<T>();
+#endif
+#if defined(__GNUC__) && __GNUC__ < 4
+    // workaround for GCC 3:
+    rhs.second = node[1].template as<U>();
+#else
+    rhs.second = node[1].as<U>();
+#endif
+    return true;
+  }
+};
+
+// binary
+template <>
+struct convert<Binary> {
+  static Node encode(const Binary& rhs) {
+    return Node(EncodeBase64(rhs.data(), rhs.size()));
+  }
+
+  static bool decode(const Node& node, Binary& rhs) {
+    if (!node.IsScalar())
+      return false;
+
+    std::vector<unsigned char> data = DecodeBase64(node.Scalar());
+    if (data.empty() && !node.Scalar().empty())
+      return false;
+
+    rhs.swap(data);
+    return true;
+  }
+};
+}
+
+#endif  // NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added directory 'dist/yaml-cpp/include/yaml-cpp/node/detail'
=== added file 'dist/yaml-cpp/include/yaml-cpp/node/detail/bool_type.h'
--- dist/yaml-cpp/include/yaml-cpp/node/detail/bool_type.h	1970-01-01 00:00:00 +0000
+++ dist/yaml-cpp/include/yaml-cpp/node/detail/bool_type.h	2016-10-18 07:57:32 +0000
@@ -0,0 +1,26 @@
+#ifndef NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+namespace detail {
+struct unspecified_bool {
+  struct NOT_ALLOWED;
+  static void true_value(NOT_ALLOWED*) {}
+};
+typedef void (*unspecified_bool_type)(unspecified_bool::NOT_ALLOWED*);
+}
+}
+
+#define YAML_CPP_OPERATOR_BOOL()                                            \
+  operator YAML::detail::unspecified_bool_type() const {                    \
+    return this->operator!() ? 0                                            \
+                             : &YAML::detail::unspecified_bool::true_value; \
+  }
+
+#endif  // NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
=== added file 'dist/yaml-cpp/include/yaml-cpp/node/detail/impl.h'
--- dist/yaml-cpp/include/yaml-cpp/node/detail/impl.h	1970-01-01 00:00:00 +0000