Merge lp:~zeller-benjamin/qtcreator-plugin-ubuntu/snapcraft-step2 into lp:qtcreator-plugin-ubuntu

[Benjamin Zeller]

Implementing Part2 of the snapcraft plan

Implementing Part2 of the snapcraft plan

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

FAILED: Continuous integration, rev:473
https://jenkins.ubuntu.com/ubuntu-sdk/job/qtcreator-ide-ci-amd64/353/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/7002/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:482
https://jenkins.ubuntu.com/ubuntu-sdk/job/qtcreator-ide-ci-amd64/356/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/7111/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:483
https://jenkins.ubuntu.com/ubuntu-sdk/job/qtcreator-ide-ci-amd64/358/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/7181/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:485
https://jenkins.ubuntu.com/ubuntu-sdk/job/qtcreator-ide-ci-amd64/363/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/7213/console

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

review: Needs Fixing (continuous-integration)

[lp:~zeller-benjamin/qtcreator-plugin-ubuntu/snapcraft-step2]

486. By Benjamin Zeller on 2016-11-14

- Superuser check
- Less messages when opening a project

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

FAILED: Continuous integration, rev:486
https://jenkins.ubuntu.com/ubuntu-sdk/job/qtcreator-ide-ci-amd64/364/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/7219/console

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

review: Needs Fixing (continuous-integration)

[lp:~zeller-benjamin/qtcreator-plugin-ubuntu/snapcraft-step2]

487. By Benjamin Zeller on 2016-11-16

Compile on trusty

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

FAILED: Continuous integration, rev:487
https://jenkins.ubuntu.com/ubuntu-sdk/job/qtcreator-ide-ci-amd64/367/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/7222/console

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

review: Needs Fixing (continuous-integration)

Unmerged revisions

487. By Benjamin Zeller on 2016-11-16

Compile on trusty

486. By Benjamin Zeller on 2016-11-14

- Superuser check
- Less messages when opening a project

485. By Benjamin Zeller on 2016-11-08

add devmode switch

484. By Benjamin Zeller on 2016-11-07

Send errors to the TaskHub

483. By Benjamin Zeller on 2016-11-04

Allow local execution of snapcraft projects.

482. By Benjamin Zeller on 2016-10-18

Support building in Ubuntu Containers

481. By Benjamin Zeller on 2016-10-18

Migrate snapcraft template to use the snapcraft project type

480. By Benjamin Zeller on 2016-10-18

Fix mimetype file

479. By Benjamin Zeller on 2016-10-18

some polishing

478. By Benjamin Zeller on 2016-10-13

- Added buildsteps
- Added buildconfiguration
- For now rsync the whole project to the build dir
- Wrap snapcraft call so "clean" is called always

=== modified file 'UbuntuPlugin.pro'
--- UbuntuPlugin.pro	2016-09-22 15:50:17 +0000
+++ UbuntuPlugin.pro	2016-11-16 10:23:00 +0000
@@ -52,7 +52,7 @@
     src/ubuntu/ubuntuproject.cpp \
     src/ubuntu/ubuntuprojectfile.cpp \
     src/ubuntu/ubuntuprojectnode.cpp \
-    #src/ubuntu/ubuntuversion.cpp \
+    src/ubuntu/ubuntuversion.cpp \
     #src/ubuntu/ubuntufeatureprovider.cpp \
     #src/ubuntu/ubuntuversionmanager.cpp \
     src/ubuntu/ubuntupackagingmode.cpp \
@@ -123,7 +123,7 @@
     src/ubuntu/ubuntuproject.h \
     src/ubuntu/ubuntuprojectfile.h \
     src/ubuntu/ubuntuprojectnode.h \
-    #src/ubuntu/ubuntuversion.h \
+    src/ubuntu/ubuntuversion.h \
     #src/ubuntu/ubuntufeatureprovider.h \
     #src/ubuntu/ubuntuversionmanager.h \
     src/ubuntu/ubuntupackagingmode.h \
@@ -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 'share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName.pro'
--- share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName.pro	2016-09-22 15:32:42 +0000
+++ 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
-}
-

=== modified file 'share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.pro'
--- share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.pro	2016-09-22 15:32:42 +0000
+++ share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.pro	2016-11-16 10:23:00 +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 'share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup'
=== added directory 'share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup/gui'
=== renamed file 'share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.desktop' => 'share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup/gui/appName.desktop'
=== renamed file 'share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/appName/appName.png' => 'share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/setup/gui/appName.png'
=== modified file 'share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/snapcraft.yaml'
--- share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/snapcraft.yaml	2016-09-22 15:32:42 +0000
+++ share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/snapcraft.yaml	2016-11-16 10:23:00 +0000
@@ -11,13 +11,19 @@
 
 parts:
   %{ProjectNameL}:
-    plugin: dump
-    source: deploy/
+    plugin: qmake
+    source: %{ProjectNameL}/
+    qt-version: qt5
+    options: ["CONFIG+=snapcraft"]
+    project-files: [%{ProjectNameL}.pro]
+    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 'share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/wizard.json'
--- share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/wizard.json	2016-09-22 15:32:42 +0000
+++ share/qtcreator/templates/wizards/ubuntu/snap-qtquick-app-qmake/wizard.json	2016-11-16 10:23:00 +0000
@@ -1,17 +1,17 @@
 {
     "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 && Ubuntu.supportsSnappy()}",
 
     "options":
     [
-        { "key": "ProjectFile", "value": "%{JS: Util.fileName('%{ProjectDirectory}/%{ProjectName}', 'pro')}" },
+        { "key": "ProjectFile", "value": "%{JS: Util.fileName('%{ProjectDirectory}/snapcraft','yaml')}" },
         { "key": "ProjectNameL", "value": "%{JS: \"%{ProjectName}\".toLowerCase()}" },
         { "key": "CppFileName", "value": "%{JS: 'main.' + Util.preferredSuffix('text/x-c++src')}" },
         { "key": "IsTopLevelProject", "value": "%{JS: !'%{Exists:ProjectExplorer.Profile.Ids}'}" }
@@ -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 'share/qtcreator/ubuntu/scripts/qtc_desktop_snaprunner.py'
--- share/qtcreator/ubuntu/scripts/qtc_desktop_snaprunner.py	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/scripts/qtc_desktop_snaprunner.py	2016-11-16 10:23:00 +0000
@@ -0,0 +1,90 @@
+#!/usr/bin/python3
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# QTC device applauncher
+# Copyright (C) 2014 Canonical
+#
+# This program 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 3 of the License, or
+# (at your option) any later version.
+#
+# 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 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/>.
+#
+# Author: Benjamin Zeller <[e-mail]>
+
+import os
+import os.path
+import subprocess
+import argparse
+import signal
+import sys
+
+# register options to the argument parser
+parser = argparse.ArgumentParser(description="SDK snap launcher")
+parser.add_argument('snap_package',action="store")
+parser.add_argument('snap_command',action='store')
+parser.add_argument('--devmode'   ,action='store_true')
+
+options, args = parser.parse_known_args()
+
+if not os.path.isfile(options.snap_package):
+    print("Snap file does not exist")
+    sys.exit(1)
+
+#parse the package name which should be  application_version_arch.snap
+app_info = os.path.basename(options.snap_package)[:-5].split("_")
+if len(app_info) != 3:
+    print("The snap package name is invalid", file=sys.stderr)
+    sys.exit(1)
+
+#flush all descriptors
+sys.stdout.flush()
+sys.stderr.flush()
+
+#ok lets install the snap package
+snaparg = ["snap", "install", options.snap_package, "--dangerous"]
+if options.devmode:
+    print("Enabling devmode\n")
+    snaparg += ["--devmode"]
+ret = subprocess.call(snaparg, stdout=sys.stdout, stderr=sys.stderr)
+if ret != 0:
+    sys.exit(ret)
+
+#flush all descriptors
+sys.stdout.flush()
+sys.stderr.flush()
+
+#this will contain the actual subprocess object
+proc = None
+stopped = False
+def signalHandler(signum, frame):
+    print('Signal handler called with signal', signum)
+    if proc is not None:
+        proc.kill()
+    else:
+        stopped = True
+
+signal.signal(signal.SIGINT,  signalHandler)
+signal.signal(signal.SIGTERM, signalHandler)
+signal.signal(signal.SIGHUP,  signalHandler)
+
+#start the actual app
+print("Command args are: "+str(args)+"\n")
+if not stopped:
+    proc = subprocess.Popen(["snap", "run", app_info[0]+"."+options.snap_command]+args, stdout=sys.stdout, stderr=sys.stderr)
+    ret = proc.wait()
+
+#flush all descriptors
+sys.stdout.flush()
+sys.stderr.flush()
+
+subprocess.call(["snap", "remove", app_info[0]], stdout=sys.stdout, stderr=sys.stderr)
+
+sys.exit(ret)

=== added file 'share/qtcreator/ubuntu/scripts/run_snapcraft.py'
--- share/qtcreator/ubuntu/scripts/run_snapcraft.py	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/scripts/run_snapcraft.py	2016-11-16 10:23:00 +0000
@@ -0,0 +1,51 @@
+#!/usr/bin/python3
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# QTC device applauncher
+# Copyright (C) 2014 Canonical
+#
+# This program 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 3 of the License, or
+# (at your option) any later version.
+#
+# 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 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/>.
+#
+# Author: Benjamin Zeller <[e-mail]>
+
+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)
+
+sys.stdout.flush()
+sys.stderr.flush()
+
+ret = subprocess.call([options.snapcraft, "clean"])
+if ret != 0:
+    sys.exit(ret)
+
+sys.exit(subprocess.call([options.snapcraft]+args))

=== modified file 'src/ubuntu/UbuntuProject.mimetypes.xml'
--- src/ubuntu/UbuntuProject.mimetypes.xml	2015-03-06 15:02:08 +0000
+++ src/ubuntu/UbuntuProject.mimetypes.xml	2016-11-16 10:23:00 +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>

=== modified file 'src/ubuntu/clicktoolchain.cpp'
--- src/ubuntu/clicktoolchain.cpp	2016-09-22 13:17:48 +0000
+++ src/ubuntu/clicktoolchain.cpp	2016-11-16 10:23:00 +0000
@@ -62,6 +62,11 @@
                                                            ProjectExplorer::Abi::GenericLinuxFlavor,
                                                            ProjectExplorer::Abi::ElfFormat,
                                                            64));
+    map.insert(QLatin1String("arm64") , ProjectExplorer::Abi(ProjectExplorer::Abi::ArmArchitecture,
+                                                             ProjectExplorer::Abi::LinuxOS,
+                                                             ProjectExplorer::Abi::GenericLinuxFlavor,
+                                                             ProjectExplorer::Abi::ElfFormat,
+                                                             64));
     return map;
 }
 
@@ -130,6 +135,15 @@
     return clickArchitectures[arch];
 }
 
+QString ClickToolChain::abiToArchitectureName(const ProjectExplorer::Abi &abi)
+{
+    for (auto i = clickArchitectures.constBegin(); i != clickArchitectures.constEnd(); i++){
+        if (i.value() == abi)
+            return i.key();
+    }
+    return QString("unknown");
+}
+
 QList<QString> ClickToolChain::supportedArchitectures()
 {
     return clickArchitectures.keys();
@@ -158,7 +172,13 @@
 {
     switch(abi.architecture()) {
         case ProjectExplorer::Abi::ArmArchitecture:
-            return QLatin1String("arm-linux-gnueabihf");
+            switch(abi.wordWidth())
+            {
+                case 32:
+                    return QLatin1String("arm-linux-gnueabihf");
+                case 64:
+                    return QLatin1String("aarch64-linux-gnu");
+            }
             break;
         case ProjectExplorer::Abi::X86Architecture:
             switch(abi.wordWidth())

=== modified file 'src/ubuntu/clicktoolchain.h'
--- src/ubuntu/clicktoolchain.h	2016-09-22 13:17:48 +0000
+++ src/ubuntu/clicktoolchain.h	2016-11-16 10:23:00 +0000
@@ -50,6 +50,7 @@
     const UbuntuClickTool::Target &clickTarget () const;
 
     static ProjectExplorer::Abi architectureNameToAbi ( const QString &arch );
+    static QString abiToArchitectureName ( const ProjectExplorer::Abi &abi );
     static QList<QString> supportedArchitectures ();
 
     QString remoteCompilerCommand () const;

=== added directory 'src/ubuntu/snap/project'
=== added file 'src/ubuntu/snap/project/snapcraftbuildconfiguration.cpp'
--- src/ubuntu/snap/project/snapcraftbuildconfiguration.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftbuildconfiguration.cpp	2016-11-16 10:23:00 +0000
@@ -0,0 +1,44 @@
+#include "snapcraftbuildconfiguration.h"
+
+#include <ubuntu/ubuntuconstants.h>
+#include <QDebug>
+
+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
+{
+    QVariantMap data = ProjectExplorer::BuildConfiguration::toMap();
+    qDebug()<<"Storing ID: "<<ProjectExplorer::idFromMap(data);
+    return data;
+}
+
+ProjectExplorer::NamedWidget *SnapcraftBuildConfiguration::createConfigWidget()
+{
+    return nullptr;
+}
+
+ProjectExplorer::BuildConfiguration::BuildType SnapcraftBuildConfiguration::buildType() const
+{
+    return ProjectExplorer::BuildConfiguration::Unknown;
+}
+
+} // namespace Internal
+} // namespace Ubuntu

=== added file 'src/ubuntu/snap/project/snapcraftbuildconfiguration.h'
--- src/ubuntu/snap/project/snapcraftbuildconfiguration.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftbuildconfiguration.h	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.cpp'
--- src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.cpp	2016-11-16 10:23:00 +0000
@@ -0,0 +1,154 @@
+#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 <projectexplorer/kitinformation.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 {};
+
+    //restrict this to local devices type kits for now
+    if (ProjectExplorer::DeviceKitInformation::deviceId(parent->kit()) != ProjectExplorer::Constants::DESKTOP_DEVICE_ID)
+        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;
+
+    //restrict this to local devices type kits for now
+    if (ProjectExplorer::DeviceKitInformation::deviceId(k) != ProjectExplorer::Constants::DESKTOP_DEVICE_ID)
+        return {};
+
+    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 'src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.h'
--- src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftbuildconfigurationfactory.h	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftbuildstepfactory.cpp'
--- src/ubuntu/snap/project/snapcraftbuildstepfactory.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftbuildstepfactory.cpp	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftbuildstepfactory.h'
--- src/ubuntu/snap/project/snapcraftbuildstepfactory.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftbuildstepfactory.h	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftproject.cpp'
--- src/ubuntu/snap/project/snapcraftproject.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftproject.cpp	2016-11-16 10:23:00 +0000
@@ -0,0 +1,214 @@
+/*
+ * 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 <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/taskhub.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;
+
+enum {
+    debug = 0
+};
+
+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.data(), &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()
+{
+    if(debug) qDebug()<<"Syncing from yaml";
+
+    QString oldDisplayName = displayName();
+
+    try {
+        YAML::Node yaml = YAML::LoadFile(m_fileName.toString().toStdString());
+        if (!m_rootNode->syncFromYAMLNode(yaml)) {
+            ProjectExplorer::TaskHub::addTask(ProjectExplorer::Task::Error,
+                                              QString::fromLatin1("Error while parsing snapcraft.yaml: file is invalid"),
+                                              ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM,
+                                              projectFilePath());
+        }
+
+        QStringList commandList;
+
+        try {
+            YAML::Node commands = yaml["apps"];
+            if (!commands.IsMap()) {
+                ProjectExplorer::TaskHub::addTask(ProjectExplorer::Task::Error,
+                                                  QString::fromLatin1("Error while parsing snapcraft.yaml: apps is not a map"),
+                                                  ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM,
+                                                  projectFilePath());
+            } else {
+                for (auto it = commands.begin(); it != commands.end(); ++it) {
+                    if(!it->second.IsMap() || it->second["daemon"])
+                        continue;
+
+                    commandList << QString::fromStdString(it->first.as<std::string>());
+                }
+            }
+
+            if(yaml["version"]) {
+                QString snapVer = QString::fromStdString(yaml["version"].as<std::string>());
+                if (snapVer != m_snapVersion) {
+                    if(debug) qDebug()<<"Snap version is"<<snapVer;
+                    m_snapVersion = snapVer;
+                    emit snapVersionChanged();
+                }
+            }
+
+        } catch (const YAML::Exception &e) {
+            ProjectExplorer::TaskHub::addTask(ProjectExplorer::Task::Error,
+                                              QString::fromLatin1("Error while parsing the command list: %1").arg(QString::fromLatin1(e.what())),
+                                              ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM,
+                                              projectFilePath(),
+                                              e.mark.line);
+        }
+
+        if (m_commands != commandList) {
+            m_commands = commandList;
+            emit commandListChanged(m_commands);
+        }
+
+    } catch (const YAML::Exception &e) {
+        ProjectExplorer::TaskHub::addTask(ProjectExplorer::Task::Error,
+                                          QString::fromLatin1("Error while parsing the project file: %1").arg(QString::fromLatin1(e.what())),
+                                          ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM,
+                                          projectFilePath(),
+                                          e.mark.line);
+    }
+
+    if (oldDisplayName != displayName())
+        emit displayNameChanged();
+}
+
+void SnapcraftProject::maybeUpdate(const QString &pathChanged)
+{
+    if (QFileInfo(pathChanged) == projectDirectory().toFileInfo()) {
+        asyncUpdate();
+    }
+}

=== added file 'src/ubuntu/snap/project/snapcraftproject.h'
--- src/ubuntu/snap/project/snapcraftproject.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftproject.h	2016-11-16 10:23:00 +0000
@@ -0,0 +1,102 @@
+/*
+ * 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;
+    QString snapVersion() const{
+        return m_snapVersion;
+    }
+
+    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();
+    }
+
+    QStringList commands () const {
+        return m_commands;
+    }
+
+    // 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);
+
+signals:
+    void commandListChanged (const QStringList &commands);
+    void snapVersionChanged ();
+
+private:
+    SnapcraftProjectManager *m_manager;
+    QString m_projectName;
+    QStringList m_commands;
+    QString m_snapVersion;
+    QPointer<SnapcraftProjectFile> m_file;
+
+    Utils::FileName m_fileName;
+    QSharedPointer<SnapcraftProjectNode> m_rootNode;
+    QFileSystemWatcher m_watcher;
+};
+}
+}
+
+#endif // SNAPCRAFTPROJECT_H

=== added file 'src/ubuntu/snap/project/snapcraftprojectfile.cpp'
--- src/ubuntu/snap/project/snapcraftprojectfile.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftprojectfile.cpp	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftprojectfile.h'
--- src/ubuntu/snap/project/snapcraftprojectfile.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftprojectfile.h	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftprojectmanager.cpp'
--- src/ubuntu/snap/project/snapcraftprojectmanager.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftprojectmanager.cpp	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftprojectmanager.h'
--- src/ubuntu/snap/project/snapcraftprojectmanager.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftprojectmanager.h	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftprojectnode.cpp'
--- src/ubuntu/snap/project/snapcraftprojectnode.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftprojectnode.cpp	2016-11-16 10:23:00 +0000
@@ -0,0 +1,517 @@
+/*
+ * 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 "snapcraftproject.h"
+
+#include <projectexplorer/nodesvisitor.h>
+#include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/taskhub.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 {
+
+enum {
+    debug = 0
+};
+
+
+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().toFileInfo().fileName());
+    setIcon(generateProjectIcon());
+}
+
+SnapcraftProjectNode::~SnapcraftProjectNode()
+{
+}
+
+bool SnapcraftProjectNode::syncFromYAMLNode(YAML::Node rootNode)
+{
+    if(debug) 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()) {
+            ProjectExplorer::TaskHub::addTask(ProjectExplorer::Task::Error,
+                                              QString::fromLatin1("Error while parsing snapcraft.yaml: parts is not a map"),
+                                              ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM,
+                                              m_rootProject->projectFilePath());
+            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();
+
+        if(debug) {
+            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) {
+        ProjectExplorer::TaskHub::addTask(ProjectExplorer::Task::Error,
+                                          QString::fromLatin1("Error while parsing snapcraft.yaml: %1").arg(QString::fromLatin1(e.what())),
+                                          ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM,
+                                          m_rootProject->projectFilePath(),
+                                          e.mark.line);
+        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())) {
+        if(debug) qDebug()<<"Added"<<folderPath.toString()<<"to watcher";
+    } else {
+        if(debug) 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;
+
+    if(debug)  qDebug()<<"Scheduling Project scan";
+
+    m_scanning = true;
+
+    QTimer *rescanTimer = new QTimer();
+    rescanTimer->setSingleShot(true);
+    rescanTimer->start(0);
+    QObject::connect(rescanTimer, &QTimer::timeout, [this, rescanTimer](){
+        if(debug) 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;
+
+    if(debug) {
+        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();
+    }
+
+    if (!watches.isEmpty())
+        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 'src/ubuntu/snap/project/snapcraftprojectnode.h'
--- src/ubuntu/snap/project/snapcraftprojectnode.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftprojectnode.h	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftrsyncstep.cpp'
--- src/ubuntu/snap/project/snapcraftrsyncstep.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftrsyncstep.cpp	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftrsyncstep.h'
--- src/ubuntu/snap/project/snapcraftrsyncstep.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftrsyncstep.h	2016-11-16 10:23:00 +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 'src/ubuntu/snap/project/snapcraftstep.cpp'
--- src/ubuntu/snap/project/snapcraftstep.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftstep.cpp	2016-11-16 10:23:00 +0000
@@ -0,0 +1,139 @@
+#include "snapcraftstep.h"
+#include "snapcraftproject.h"
+#include "snapcraftbuildconfiguration.h"
+
+#include <ubuntu/snap/settings/snapcraftkitinformation.h>
+#include <ubuntu/ubuntuconstants.h>
+#include <ubuntu/clicktoolchain.h>
+
+#include <projectexplorer/target.h>
+#include <utils/environment.h>
+
+#include <QRegularExpression>
+
+
+namespace Ubuntu {
+namespace Internal {
+
+static const char * PACKAGE_NAME_REGEX = "^Snapped ([\\S]+\\.snap)$";
+
+SnapcraftStep::SnapcraftStep(ProjectExplorer::BuildStepList *bsl)
+    : ProjectExplorer::AbstractProcessStep(bsl, Constants::SNAPCRAFT_BUILDSTEP_ID)
+{
+    setDefaultDisplayName(tr("Snapcraft"));
+
+    connect(qobject_cast<SnapcraftProject *>(target()->project()), &SnapcraftProject::snapVersionChanged,
+            this, &SnapcraftStep::packagePathChanged);
+    connect(qobject_cast<SnapcraftProject *>(target()->project()), &SnapcraftProject::displayNameChanged,
+            this, &SnapcraftStep::packagePathChanged);
+}
+
+SnapcraftStep::SnapcraftStep(ProjectExplorer::BuildStepList *bsl, SnapcraftStep *bs)
+    : ProjectExplorer::AbstractProcessStep(bsl, bs)
+{
+    connect(qobject_cast<SnapcraftProject *>(target()->project()), &SnapcraftProject::snapVersionChanged,
+            this, &SnapcraftStep::packagePathChanged);
+    connect(qobject_cast<SnapcraftProject *>(target()->project()), &SnapcraftProject::displayNameChanged,
+            this, &SnapcraftStep::packagePathChanged);
+}
+
+void SnapcraftStep::stdOutput(const QString &line)
+{
+    m_lastLine = line;
+    ProjectExplorer::AbstractProcessStep::stdOutput(line);
+}
+
+void SnapcraftStep::processStarted()
+{
+    m_packagePath.clear();
+    emit packagePathChanged();
+
+    ProjectExplorer::AbstractProcessStep::processStarted();
+}
+
+void SnapcraftStep::processFinished(int exitCode, QProcess::ExitStatus status)
+{
+    Utils::FileName newPackagePath;
+
+    ProjectExplorer::AbstractProcessStep::processFinished(exitCode, status);
+    if (status == QProcess::NormalExit && exitCode == 0) {
+        QRegularExpression exp((QLatin1String(PACKAGE_NAME_REGEX)));
+        QRegularExpressionMatch m = exp.match(m_lastLine);
+        if(m.hasMatch()) {
+            ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration();
+            if(bc)
+                newPackagePath = bc->buildDirectory().appendPath(m.captured(1));
+        }
+    }
+
+    if (m_packagePath != newPackagePath) {
+        m_packagePath = newPackagePath;
+        emit packagePathChanged();
+    }
+}
+
+bool SnapcraftStep::processSucceeded(int exitCode, QProcess::ExitStatus status)
+{
+    if (!ProjectExplorer::AbstractProcessStep::processSucceeded(exitCode, status))
+        return false;
+
+    return m_packagePath.toFileInfo().exists();
+}
+
+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;
+}
+
+Utils::FileName SnapcraftStep::packagePath() const
+{
+    if (!m_packagePath.isEmpty())
+        return m_packagePath;
+
+    ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration();
+    SnapcraftProject *pro = qobject_cast<SnapcraftProject *>(target()->project());
+    ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit());
+    if(bc && pro && tc && !pro->displayName().isEmpty() && !pro->snapVersion().isEmpty())
+        return bc->buildDirectory().appendPath(QStringLiteral("%1_%2_%3.snap")
+                                                         .arg(pro->displayName())
+                                                         .arg(pro->snapVersion())
+                                                         .arg(ClickToolChain::abiToArchitectureName(tc->targetAbi())));
+    return Utils::FileName();
+}
+
+} // namespace Internal
+} // namespace Ubuntu

=== added file 'src/ubuntu/snap/project/snapcraftstep.h'
--- src/ubuntu/snap/project/snapcraftstep.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snapcraftstep.h	2016-11-16 10:23:00 +0000
@@ -0,0 +1,50 @@
+#ifndef UBUNTU_INTERNAL_SNAPCRAFTSTEP_H
+#define UBUNTU_INTERNAL_SNAPCRAFTSTEP_H
+
+#include <projectexplorer/abstractprocessstep.h>
+#include <utils/fileutils.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;
+    Utils::FileName packagePath () const;
+
+signals:
+    void packagePathChanged ();
+
+protected:
+    SnapcraftStep(ProjectExplorer::BuildStepList *bsl);
+    SnapcraftStep(ProjectExplorer::BuildStepList *bsl, SnapcraftStep *bs);
+
+    // AbstractProcessStep interface
+    virtual void stdOutput(const QString &line);
+    virtual void processStarted() override;
+    virtual void processFinished(int exitCode, QProcess::ExitStatus status) override;
+    virtual bool processSucceeded(int exitCode, QProcess::ExitStatus status) override;
+
+
+
+private:
+    QString m_lastLine;
+    Utils::FileName m_packagePath;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPCRAFTSTEP_H

=== added file 'src/ubuntu/snap/project/snaprunconfiguration.cpp'
--- src/ubuntu/snap/project/snaprunconfiguration.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snaprunconfiguration.cpp	2016-11-16 10:23:00 +0000
@@ -0,0 +1,273 @@
+#include "snaprunconfiguration.h"
+#include "snapcraftstep.h"
+#include "snapcraftproject.h"
+
+#include <ubuntu/ubuntuconstants.h>
+
+#include <projectexplorer/runnables.h>
+#include <projectexplorer/target.h>
+#include <projectexplorer/buildconfiguration.h>
+#include <projectexplorer/buildstep.h>
+#include <projectexplorer/buildsteplist.h>
+#include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/localenvironmentaspect.h>
+#include <projectexplorer/runconfigurationaspects.h>
+#include <utils/qtcprocess.h>
+#include <utils/pathchooser.h>
+
+#include <QFileInfo>
+#include <QFormLayout>
+#include <QComboBox>
+#include <QCheckBox>
+
+namespace Ubuntu {
+namespace Internal {
+
+const QString COMMAND_KEY = QStringLiteral("SnapProjectManager.SnapRunConfiguration.SnapCommand");
+const QString DEVMODE_KEY = QStringLiteral("SnapProjectManager.SnapRunConfiguration.SnapDevMode");
+const QString WORKINGDIRECTORYASPECT_ID = QStringLiteral("SnapProjectManager.SnapRunConfiguration.WorkingDirectoryAspect");
+const QString ARGUMENTASPECT_ID = QStringLiteral("SnapProjectManager.SnapRunConfiguration.ArgumentAspect");
+const QString TERMINALASPECT_ID = QStringLiteral("SnapProjectManager.SnapRunConfiguration.TerminalAspect");
+
+SnapRunConfiguration::SnapRunConfiguration(ProjectExplorer::Target *parent)
+    : ProjectExplorer::RunConfiguration(parent, Constants::SNAP_RUNCONFIGURATION_ID)
+    , m_useDevMode(true)
+    , m_workingDirectoryAspect(new ProjectExplorer::WorkingDirectoryAspect(this, WORKINGDIRECTORYASPECT_ID))
+    , m_argumentAspect(new ProjectExplorer::ArgumentsAspect(this, ARGUMENTASPECT_ID))
+    , m_terminalAspect(new ProjectExplorer::TerminalAspect(this, TERMINALASPECT_ID))
+    , m_localEnvironmentAspect(new ProjectExplorer::LocalEnvironmentAspect(this, ProjectExplorer::LocalEnvironmentAspect::BaseEnvironmentModifier()))
+{
+    m_terminalAspect->setRunMode(ProjectExplorer::ApplicationLauncher::Gui);
+
+    addExtraAspect(m_argumentAspect);
+    addExtraAspect(m_terminalAspect);
+    addExtraAspect(m_localEnvironmentAspect);
+    addExtraAspect(m_workingDirectoryAspect);
+
+    if(parent) {
+        SnapcraftProject *pro = qobject_cast<SnapcraftProject *>(parent->project());
+        if (pro) {
+            setDisplayName(pro->displayName());
+            QStringList comms = pro->commands();
+            if (comms.size())
+                m_command = comms.first();
+        }
+         m_workingDirectoryAspect->setDefaultWorkingDirectory(Utils::FileName::fromString(pro->projectDir().absolutePath()));
+    }
+
+    // Connect target signals
+    connect(this->target(), &ProjectExplorer::Target::activeBuildConfigurationChanged,
+            this, &SnapRunConfiguration::updateConfiguration);
+    updateConfiguration();
+}
+
+SnapRunConfiguration::SnapRunConfiguration(ProjectExplorer::Target *parent, SnapRunConfiguration *source)
+    : ProjectExplorer::RunConfiguration(parent, source),
+      m_command(source->m_command)
+{
+    // Connect target signals
+    connect(this->target(), &ProjectExplorer::Target::activeBuildConfigurationChanged,
+            this, &SnapRunConfiguration::updateConfiguration);
+    updateConfiguration();
+}
+
+QString SnapRunConfiguration::command() const
+{
+    return m_command;
+}
+
+void SnapRunConfiguration::setCommand(const QString &command)
+{
+    if (command != m_command) {
+        m_command = command;
+        emit enabledChanged();
+    }
+}
+
+bool SnapRunConfiguration::fromMap(const QVariantMap &map)
+{
+    if (!ProjectExplorer::RunConfiguration::fromMap(map))
+        return false;
+
+    m_command = map.value(COMMAND_KEY, QString()).toString();
+    m_useDevMode = map.value(DEVMODE_KEY, true).toBool();
+    return true;
+}
+
+QVariantMap SnapRunConfiguration::toMap() const
+{
+    QVariantMap map = ProjectExplorer::RunConfiguration::toMap();
+    map.insert(COMMAND_KEY, m_command);
+    map.insert(DEVMODE_KEY, m_useDevMode);
+    return map;
+}
+
+bool SnapRunConfiguration::isEnabled() const
+{
+    return !m_command.isEmpty();
+}
+
+QString SnapRunConfiguration::disabledReason() const
+{
+    return tr("Please select a command to run in the runconfiguration.");
+}
+
+QWidget *SnapRunConfiguration::createConfigurationWidget()
+{
+    return new SnapRunConfigurationWidget(this);
+}
+
+ProjectExplorer::Runnable SnapRunConfiguration::runnable() const
+{
+    SnapcraftStep *pckStep = activeSnapcraftStep();
+    if (!pckStep) {
+        return ProjectExplorer::Runnable();
+    }
+
+    Utils::FileName packagePath = pckStep->packagePath();
+    if(packagePath.isEmpty()) {
+        return ProjectExplorer::Runnable();
+    }
+
+    qDebug()<<"Going to run "<<packagePath.toUserOutput();
+
+    QStringList args{
+        packagePath.toUserOutput(),
+        m_command
+    };
+
+    if (m_useDevMode)
+        args.prepend(QStringLiteral("--devmode"));
+
+    ProjectExplorer::StandardRunnable r;
+    r.executable = Utils::FileName::fromString(Constants::UBUNTU_SCRIPTPATH).appendPath(QStringLiteral("qtc_desktop_snaprunner.py")).toString();;
+    r.workingDirectory = m_workingDirectoryAspect->workingDirectory().toString();
+    r.environment = m_localEnvironmentAspect->environment();
+    r.commandLineArguments = Utils::QtcProcess::joinArgs(args);
+    if (!m_argumentAspect->arguments().isEmpty()) {
+        r.commandLineArguments.append(QStringLiteral(" -- %1").arg(m_argumentAspect->arguments()));
+    }
+    return r;
+}
+
+SnapcraftStep *SnapRunConfiguration::activeSnapcraftStep() const
+{
+    ProjectExplorer::BuildConfiguration *buildConf = activeBuildConfiguration();
+    if(!buildConf)
+        return nullptr;
+
+    ProjectExplorer::BuildStepList *bsList = buildConf->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
+    for(ProjectExplorer::BuildStep *currStep : bsList->steps()) {
+        SnapcraftStep *pckStep = qobject_cast<SnapcraftStep*>(currStep);
+        if(pckStep)
+            return pckStep;
+    }
+    return nullptr;
+}
+
+void SnapRunConfiguration::updateConfiguration()
+{
+    if(m_currBuildConfConn)
+        disconnect(m_currBuildConfConn);
+
+    m_currBuildConfConn = connect(activeSnapcraftStep(), &SnapcraftStep::packagePathChanged,
+                                  this, &ProjectExplorer::RunConfiguration::requestRunActionsUpdate);
+
+}
+
+bool SnapRunConfiguration::useDevMode() const
+{
+    return m_useDevMode;
+}
+
+void SnapRunConfiguration::setUseDevMode(bool useDevMode)
+{
+    m_useDevMode = useDevMode;
+}
+
+SnapRunConfigurationWidget::SnapRunConfigurationWidget(SnapRunConfiguration *config)
+    : QWidget (nullptr),
+      m_rc(config),
+      m_updating(false)
+{
+    QFormLayout *layout = new QFormLayout(this);
+    layout->setMargin(0);
+    layout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
+
+    setLayout(layout);
+
+    m_commandsBox = new QComboBox(this);
+    updateComboBox();
+
+    connect(m_commandsBox, SIGNAL(currentIndexChanged(int)),
+            this, SLOT(commandSelected(int)));
+
+    int idx = m_commandsBox->findText(config->command());
+    if (idx >= 0)
+        m_commandsBox->setCurrentIndex(idx);
+
+    m_devmodeCheckBox = new QCheckBox(tr("Use devmode"), this);
+    m_devmodeCheckBox->setChecked(config->useDevMode());
+    connect(m_devmodeCheckBox, &QCheckBox::stateChanged,
+            this, &SnapRunConfigurationWidget::devModeStateChanged);
+
+    layout->addRow(tr("Command:"), m_commandsBox);
+    config->extraAspect<ProjectExplorer::ArgumentsAspect>()->addToMainConfigurationWidget(this, layout);
+    config->extraAspect<ProjectExplorer::WorkingDirectoryAspect>()->addToMainConfigurationWidget(this,layout);
+    config->extraAspect<ProjectExplorer::TerminalAspect>()->addToMainConfigurationWidget(this,layout);
+    layout->addRow(QStringLiteral(""), m_devmodeCheckBox);
+
+    if(config->target()) {
+        connect(qobject_cast<SnapcraftProject*>(config->target()->project()), &SnapcraftProject::commandListChanged,
+                this, &SnapRunConfigurationWidget::updateComboBox);
+    }
+}
+
+void SnapRunConfigurationWidget::updateComboBox()
+{
+    QString currItem = m_rc->command();
+
+    //TODO check if project is still loading, so we do not override something we need
+
+    m_updating = true;
+    m_commandsBox->clear();
+    m_commandsBox->addItem(QString());
+    if(m_rc && m_rc->target()) {
+        SnapcraftProject *pro = qobject_cast<SnapcraftProject *>(m_rc->target()->project());
+        if (pro) {
+            QStringList comms = pro->commands();
+            m_commandsBox->addItems(comms);
+        }
+    }
+    m_updating = false;
+
+    int idx = m_commandsBox->findText(currItem);
+    if (idx <= 0 && m_commandsBox->count() > 1)
+        m_commandsBox->setCurrentIndex(1);
+    else if (idx > 0)
+        m_commandsBox->setCurrentIndex(idx);
+    else
+        m_commandsBox->setCurrentIndex(0);
+}
+
+void SnapRunConfigurationWidget::devModeStateChanged(int state)
+{
+    if (state == Qt::Checked)
+        m_rc->setUseDevMode(true);
+    else
+        m_rc->setUseDevMode(false);
+}
+
+void SnapRunConfigurationWidget::commandSelected(const int index)
+{
+    if(m_updating)
+        return;
+
+    if(index == 0)
+        m_rc->setCommand(QString());
+    else
+        m_rc->setCommand(m_commandsBox->itemText(index));
+}
+
+} // namespace Internal
+} // namespace Ubuntu

=== added file 'src/ubuntu/snap/project/snaprunconfiguration.h'
--- src/ubuntu/snap/project/snaprunconfiguration.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snaprunconfiguration.h	2016-11-16 10:23:00 +0000
@@ -0,0 +1,94 @@
+#ifndef UBUNTU_INTERNAL_SNAPRUNCONFIGURATION_H
+#define UBUNTU_INTERNAL_SNAPRUNCONFIGURATION_H
+
+#include "snaprunconfigurationfactory.h"
+
+#include <projectexplorer/runconfiguration.h>
+#include <utils/fileutils.h>
+
+#include <QStringList>
+
+class QComboBox;
+class QCheckBox;
+
+namespace Utils {
+    class PathChooser;
+}
+
+namespace ProjectExplorer {
+    class WorkingDirectoryAspect;
+    class ArgumentsAspect;
+    class TerminalAspect;
+    class LocalEnvironmentAspect;
+}
+
+namespace Ubuntu {
+namespace Internal {
+
+class SnapcraftStep;
+
+class SnapRunConfiguration : public ProjectExplorer::RunConfiguration
+{
+    Q_OBJECT
+    friend class SnapRunConfigurationFactory;
+protected:
+    SnapRunConfiguration(ProjectExplorer::Target *parent);
+    SnapRunConfiguration(ProjectExplorer::Target *parent, SnapRunConfiguration *source);
+
+public:
+
+    QString command () const;
+    void setCommand (const QString &command);
+
+    // ProjectConfiguration interface
+    virtual bool fromMap(const QVariantMap &map) override;
+    virtual QVariantMap toMap() const override;
+
+    // RunConfiguration interface
+    virtual bool isEnabled() const override;
+    virtual QString disabledReason() const override;
+    virtual QWidget *createConfigurationWidget() override;
+    virtual ProjectExplorer::Runnable runnable() const override;
+
+    bool useDevMode() const;
+    void setUseDevMode(bool useDevMode);
+
+private:
+    SnapcraftStep *activeSnapcraftStep() const;
+    void updateCommandList(const QStringList &commands);
+    void updateConfiguration();
+
+private:
+    QString m_command;
+    bool m_useDevMode;
+    QMetaObject::Connection m_currBuildConfConn;
+    ProjectExplorer::WorkingDirectoryAspect* m_workingDirectoryAspect;
+    ProjectExplorer::ArgumentsAspect* m_argumentAspect;
+    ProjectExplorer::TerminalAspect* m_terminalAspect;
+    ProjectExplorer::LocalEnvironmentAspect* m_localEnvironmentAspect;
+};
+
+class SnapRunConfigurationWidget : public QWidget
+{
+    Q_OBJECT
+public:
+    SnapRunConfigurationWidget(SnapRunConfiguration *config);
+
+protected:
+    void updateComboBox ();
+    void devModeStateChanged (int state);
+
+protected slots:
+    void commandSelected (const int index);
+
+private:
+    SnapRunConfiguration *m_rc;
+    QComboBox *m_commandsBox;
+    QCheckBox *m_devmodeCheckBox;
+    bool m_updating;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPRUNCONFIGURATION_H

=== added file 'src/ubuntu/snap/project/snaprunconfigurationfactory.cpp'
--- src/ubuntu/snap/project/snaprunconfigurationfactory.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snaprunconfigurationfactory.cpp	2016-11-16 10:23:00 +0000
@@ -0,0 +1,85 @@
+#include "snaprunconfigurationfactory.h"
+#include "snaprunconfiguration.h"
+#include "snapcraftproject.h"
+
+#include <ubuntu/ubuntuconstants.h>
+#include <projectexplorer/target.h>
+
+#include <utils/qtcassert.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+SnapRunConfigurationFactory::SnapRunConfigurationFactory()
+{
+    setObjectName(QStringLiteral("SnapRunConfigurationFactory"));
+}
+
+QList<Core::Id> SnapRunConfigurationFactory::availableCreationIds(ProjectExplorer::Target *parent,
+                                                                  ProjectExplorer::IRunConfigurationFactory::CreationMode mode) const
+{
+    Q_UNUSED(mode);
+
+    if (!parent)
+        return {};
+    if (!qobject_cast<SnapcraftProject *>(parent->project()))
+        return {};
+
+    return {
+        Constants::SNAP_RUNCONFIGURATION_ID
+    };
+}
+
+QString SnapRunConfigurationFactory::displayNameForId(Core::Id id) const
+{
+    if (id == Constants::SNAP_RUNCONFIGURATION_ID)
+        return tr("Snapcraft Runconfiguration");
+
+    return QString();
+}
+
+bool SnapRunConfigurationFactory::canCreate(ProjectExplorer::Target *parent, Core::Id id) const
+{
+    return availableCreationIds(parent, ProjectExplorer::IRunConfigurationFactory::AutoCreate).contains(id);
+}
+
+bool SnapRunConfigurationFactory::canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const
+{
+    return availableCreationIds(parent, ProjectExplorer::IRunConfigurationFactory::AutoCreate).contains(ProjectExplorer::idFromMap(map));
+}
+
+bool SnapRunConfigurationFactory::canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *product) const
+{
+    return availableCreationIds(parent, ProjectExplorer::IRunConfigurationFactory::AutoCreate).contains(product->id());
+}
+
+ProjectExplorer::RunConfiguration *SnapRunConfigurationFactory::clone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *product)
+{
+    QTC_ASSERT(canClone(parent, product), return nullptr);
+    return new SnapRunConfiguration(parent, static_cast<SnapRunConfiguration *>(product));
+}
+
+ProjectExplorer::RunConfiguration *SnapRunConfigurationFactory::doCreate(ProjectExplorer::Target *parent, Core::Id id)
+{
+    QTC_ASSERT(canCreate(parent, id), return nullptr);
+    if (id == Constants::SNAP_RUNCONFIGURATION_ID)
+        return new SnapRunConfiguration(parent);
+    return nullptr;
+}
+
+ProjectExplorer::RunConfiguration *SnapRunConfigurationFactory::doRestore(ProjectExplorer::Target *parent, const QVariantMap &map)
+{
+    QTC_ASSERT(canRestore(parent, map), return nullptr);
+
+    SnapRunConfiguration *conf = new SnapRunConfiguration(parent);
+    if (conf->fromMap(map))
+        return conf;
+
+    //something went wrong
+    delete conf;
+    return nullptr;
+
+}
+
+} // namespace Internal
+} // namespace Ubuntu

=== added file 'src/ubuntu/snap/project/snaprunconfigurationfactory.h'
--- src/ubuntu/snap/project/snaprunconfigurationfactory.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/project/snaprunconfigurationfactory.h	2016-11-16 10:23:00 +0000
@@ -0,0 +1,31 @@
+#ifndef UBUNTU_INTERNAL_SNAPRUNCONFIGURATIONFACTORY_H
+#define UBUNTU_INTERNAL_SNAPRUNCONFIGURATIONFACTORY_H
+
+#include <projectexplorer/runconfiguration.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class SnapRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFactory
+{
+public:
+
+    SnapRunConfigurationFactory();
+
+    // IRunConfigurationFactory interface
+    virtual QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    virtual QString displayNameForId(Core::Id id) const override;
+    virtual bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
+    virtual bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
+    virtual bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *product) const override;
+    virtual ProjectExplorer::RunConfiguration *clone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *product) override;
+
+private:
+    virtual ProjectExplorer::RunConfiguration *doCreate(ProjectExplorer::Target *parent, Core::Id id) override;
+    virtual ProjectExplorer::RunConfiguration *doRestore(ProjectExplorer::Target *parent, const QVariantMap &map) override;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_SNAPRUNCONFIGURATIONFACTORY_H

=== added directory 'src/ubuntu/snap/settings'
=== added file 'src/ubuntu/snap/settings/snapcraftkitinformation.cpp'
--- src/ubuntu/snap/settings/snapcraftkitinformation.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/settings/snapcraftkitinformation.cpp	2016-11-16 10:23:00 +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 'src/ubuntu/snap/settings/snapcraftkitinformation.h'
--- src/ubuntu/snap/settings/snapcraftkitinformation.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/settings/snapcraftkitinformation.h	2016-11-16 10:23:00 +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 'src/ubuntu/snap/snap.pri'
--- src/ubuntu/snap/snap.pri	1970-01-01 00:00:00 +0000
+++ src/ubuntu/snap/snap.pri	2016-11-16 10:23:00 +0000
@@ -0,0 +1,31 @@
+
+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 \
+    $$PWD/project/snaprunconfiguration.cpp \
+    $$PWD/project/snaprunconfigurationfactory.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 \
+    $$PWD/project/snaprunconfiguration.h \
+    $$PWD/project/snaprunconfigurationfactory.h
+

=== modified file 'src/ubuntu/snap/snapcraftpackagestep.cpp'
--- src/ubuntu/snap/snapcraftpackagestep.cpp	2016-09-22 13:17:48 +0000
+++ src/ubuntu/snap/snapcraftpackagestep.cpp	2016-11-16 10:23:00 +0000
@@ -37,7 +37,7 @@
 namespace Ubuntu {
 namespace Internal {
 
-const char * PACKAGE_NAME_REGEX = "^Snapped ([\\S]+\\.snap)$";
+static const char * PACKAGE_NAME_REGEX = "^Snapped ([\\S]+\\.snap)$";
 
 SnapcraftPackageStep::SnapcraftPackageStep(ProjectExplorer::BuildStepList *bsl)
     : ProjectExplorer::BuildStep (bsl, Constants::UBUNTU_SNAP_PACKAGESTEP_ID)

=== modified file 'src/ubuntu/ubuntuclicktool.cpp'
--- src/ubuntu/ubuntuclicktool.cpp	2016-08-18 06:42:19 +0000
+++ src/ubuntu/ubuntuclicktool.cpp	2016-11-16 10:23:00 +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 'src/ubuntu/ubuntuclicktool.h'
--- src/ubuntu/ubuntuclicktool.h	2016-07-20 14:56:52 +0000
+++ src/ubuntu/ubuntuclicktool.h	2016-11-16 10:23:00 +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 'src/ubuntu/ubuntuconstants.h'
--- src/ubuntu/ubuntuconstants.h	2016-09-22 13:17:48 +0000
+++ src/ubuntu/ubuntuconstants.h	2016-11-16 10:23:00 +0000
@@ -260,23 +260,21 @@
 const char  FEATURE_UBUNTU_TRUSTY[] = "Ubuntu.Wizards.FeatureUbuntuTrusty";
 const char  FEATURE_UBUNTU_UTOPIC[] = "Ubuntu.Wizards.FeatureUbuntuUtopic";
 
-const char  DISTRIB_ID[] = "DISTRIB_ID=";
-const char  DISTRIB_CODENAME[] = "DISTRIB_CODENAME=";
-const char  DISTRIB_RELEASE[] = "DISTRIB_RELEASE=";
-const char  DISTRIB_DESCRIPTION[] = "DISTRIB_DESCRIPTION=";
-const char  LSB_RELEASE[] = "/etc/lsb-release";
-
-const char  PRECISE[] = "precise";
-const char  QUANTAL[] = "quantal";
-const char  RARING[] = "raring";
-const char  SAUCY[] = "saucy";
-const char  TRUSTY[] = "trusty";
-const char  UTOPIC[] = "utopic";
-
 const char  PLATFORM_DESKTOP[] = "Desktop";
 const char  PLATFORM_DESKTOP_DISPLAYNAME[] = "Ubuntu %0";
+
+const QString PRECISE (QStringLiteral("precise"));
+const QString QUANTAL (QStringLiteral("quantal"));
+const QString RARING  (QStringLiteral("raring"));
+const QString SAUCY   (QStringLiteral("saucy"));
+const QString TRUSTY  (QStringLiteral("trusty"));
+const QString UTOPIC  (QStringLiteral("utopic"));
+const QString VIVID   (QStringLiteral("vivid"));
+const QString WILY    (QStringLiteral("wily"));
 */
 
+const QString XENIAL  (QStringLiteral("xenial"));
+
 const char  TASK_DEVICE_SCRIPT[] = "Ubuntu.Task.DeviceScript";
 
 const char  UBUNTU_SETTINGS_ICON[] = ":/ubuntu/images/ubuntu-32.png";
@@ -393,6 +391,17 @@
 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";
+const char SNAP_RUNCONFIGURATION_ID[]         = "SnapcraftProjectManager.SnapRunConfiguration.Id";
+
+
+
 } // namespace Ubuntu
 } // namespace Constants
 

=== modified file 'src/ubuntu/ubuntujsextension.cpp'
--- src/ubuntu/ubuntujsextension.cpp	2016-09-22 13:17:48 +0000
+++ src/ubuntu/ubuntujsextension.cpp	2016-11-16 10:23:00 +0000
@@ -15,8 +15,11 @@
  *
  * Author: Benjamin Zeller <[e-mail]>
  */
+
 #include "ubuntujsextension.h"
 #include <ubuntu/ubuntubzr.h>
+#include <ubuntu/ubuntuversion.h>
+#include <ubuntu/ubuntuconstants.h>
 
 namespace Ubuntu {
 namespace Internal {
@@ -43,4 +46,12 @@
     return maintainer;
 }
 
+bool UbuntuJsExtension::supportsSnappy() const
+{
+    UbuntuVersion *v = UbuntuVersion::instance();
+    if (v->isValid())
+        return v->supportsSnappy();
+    return false;
+}
+
 }}

=== modified file 'src/ubuntu/ubuntujsextension.h'
--- src/ubuntu/ubuntujsextension.h	2016-09-22 13:17:48 +0000
+++ src/ubuntu/ubuntujsextension.h	2016-11-16 10:23:00 +0000
@@ -30,6 +30,7 @@
     explicit UbuntuJsExtension(QObject *parent = 0);
 
     Q_INVOKABLE QString developerId() const;
+    Q_INVOKABLE bool supportsSnappy() const;
 };
 
 }}

=== modified file 'src/ubuntu/ubuntukitmanager.cpp'
--- src/ubuntu/ubuntukitmanager.cpp	2016-08-18 06:42:19 +0000
+++ src/ubuntu/ubuntukitmanager.cpp	2016-11-16 10:23:00 +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 'src/ubuntu/ubuntuplugin.cpp'
--- src/ubuntu/ubuntuplugin.cpp	2016-09-22 15:50:17 +0000
+++ src/ubuntu/ubuntuplugin.cpp	2016-11-16 10:23:00 +0000
@@ -52,6 +52,13 @@
 #include <ubuntu/wizards/ubuntuprojectapplicationwizard.h>
 #include <ubuntu/wizards/ubuntufirstrunwizard.h>
 #include <ubuntu/wizards/ubuntuprojectmigrationwizard.h>
+#include <ubuntu/ubuntuversion.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 <ubuntu/snap/project/snaprunconfiguration.h>
 
 #include "ubuntujsextension.h"
 
@@ -84,6 +91,8 @@
 
 #include <coreplugin/icore.h>
 #include <stdint.h>
+#include <unistd.h>
+#include <sys/types.h>
 
 
 using namespace Ubuntu;
@@ -116,6 +125,11 @@
     defaultFont.setFamily(QStringLiteral("Ubuntu"));
     defaultFont.setWeight(QFont::Light);
 
+
+    if (::getuid() == 0) {
+        criticalError(tr("\nThe Ubuntu SDK can not be used as superuser."));
+        return false;
+    }
     if (QStandardPaths::findExecutable(QStringLiteral("lxc")).isEmpty()) {
         criticalError(tr("\nLxd is not installed properly.\nIt is required for the Ubuntu-SDK-IDE to work."));
         return false;
@@ -175,6 +189,16 @@
     addAutoReleasedObject(new UbuntuRemoteRunControlFactory);
     addAutoReleasedObject(new UbuntuLocalRunControlFactory);
 
+
+    if (UbuntuVersion::instance()->supportsSnappy()) {
+        addAutoReleasedObject(new SnapcraftProjectManager);
+        addAutoReleasedObject(new SnapcraftBuildConfigurationFactory);
+        addAutoReleasedObject(new SnapcraftBuildStepFactory);
+        addAutoReleasedObject(new SnapRunConfigurationFactory);
+
+        ProjectExplorer::KitManager::registerKitInformation(new SnapcraftKitInformation);
+    }
+
     // Build support
     addAutoReleasedObject(new ClickToolChainFactory);
     addAutoReleasedObject(new UbuntuHtmlBuildConfigurationFactory);
@@ -379,6 +403,7 @@
 
     while (!ok) {
         QProcess proc;
+        qDebug()<<"Running "<<Constants::UBUNTU_TARGET_TOOL;
         proc.setProgram(Constants::UBUNTU_TARGET_TOOL);
 
         QStringList args{QStringLiteral("initialized")};
@@ -401,14 +426,13 @@
             case ERR_NO_ACCESS:
                     //the tool tells us that we have no access to the LXD server
                     criticalError(tr("The current user can not access the LXD server which is required for the Ubuntu SDK.\n"
-                                     "Make sure the user is part of the lxd group and restart the IDE."));
+                                     "Make sure the user is part of the lxd group, relogin and restart the IDE."));
                 break;
             case ERR_NO_BRIDGE:
                 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());

=== modified file 'src/ubuntu/ubuntuversion.cpp'
--- src/ubuntu/ubuntuversion.cpp	2014-05-27 15:53:25 +0000
+++ src/ubuntu/ubuntuversion.cpp	2016-11-16 10:23:00 +0000
@@ -21,61 +21,59 @@
 #include <QFile>
 #include <QStringList>
 
-using namespace Ubuntu::Internal;
+namespace Ubuntu {
+namespace Internal {
+
+Q_GLOBAL_STATIC(UbuntuVersion, g_instance);
+
+const char  DISTRIB_ID[] = "DISTRIB_ID=";
+const char  DISTRIB_CODENAME[] = "DISTRIB_CODENAME=";
+const char  DISTRIB_RELEASE[] = "DISTRIB_RELEASE=";
+const char  DISTRIB_DESCRIPTION[] = "DISTRIB_DESCRIPTION=";
+const char  LSB_RELEASE[] = "/etc/lsb-release";
 
 UbuntuVersion::UbuntuVersion()
 {
-
-}
-
-Core::FeatureSet UbuntuVersion::features() {
-    Core::FeatureSet retval;
-
-    QString cName = codename();
-    if (cName==QLatin1String(Constants::PRECISE)) {
-        retval |= Core::FeatureSet(Constants::FEATURE_UBUNTU_PRECISE);
-    } else if (cName==QLatin1String(Constants::QUANTAL)) {
-        retval |= Core::FeatureSet(Constants::FEATURE_UBUNTU_QUANTAL);
-    } else if (cName==QLatin1String(Constants::RARING)) {
-        retval |= Core::FeatureSet(Constants::FEATURE_UBUNTU_RARING);
-    } else if (cName==QLatin1String(Constants::SAUCY)) {
-        retval |= Core::FeatureSet(Constants::FEATURE_UBUNTU_SAUCY);
-        retval |= Core::FeatureSet(Constants::FEATURE_UNITY_SCOPE);
-    } else if  (cName==QLatin1String(Constants::TRUSTY)) {
-        retval |= Core::FeatureSet(Constants::FEATURE_UBUNTU_TRUSTY);
-        retval |= Core::FeatureSet(Constants::FEATURE_UNITY_SCOPE);
-    } else if (cName==QLatin1String(Constants::UTOPIC)) {
-        retval |= Core::FeatureSet(Constants::FEATURE_UBUNTU_UTOPIC);
-        retval |= Core::FeatureSet(Constants::FEATURE_UNITY_SCOPE);
-    }
-    return retval;
-}
-
-UbuntuVersion *UbuntuVersion::fromLsbFile(const QString &fileName)
-{
-    QFile lsbRelease(fileName);
+    initFromLsbFile();
+}
+
+bool UbuntuVersion::supportsSnappy() const
+{
+    if (m_valid)
+        return codename() == Constants::XENIAL;
+    return false;
+}
+
+UbuntuVersion *UbuntuVersion::instance()
+{
+    return g_instance();
+}
+
+void UbuntuVersion::initFromLsbFile()
+{
+    QFile lsbRelease(QString::fromLatin1(LSB_RELEASE));
     if (lsbRelease.open(QIODevice::ReadOnly)) {
         QByteArray data = lsbRelease.readAll();
         lsbRelease.close();
 
-        UbuntuVersion *ver = new UbuntuVersion;
-
         foreach(QString line, QString::fromLatin1(data).split(QLatin1String("\n"))) {
-            if (line.startsWith(QLatin1String(Constants::DISTRIB_ID))) {
-                ver->m_id = line.replace(QLatin1String(Constants::DISTRIB_ID),QLatin1String(""));
-
-            } else if (line.startsWith(QLatin1String(Constants::DISTRIB_RELEASE))) {
-                ver->m_release = line.replace(QLatin1String(Constants::DISTRIB_RELEASE),QLatin1String(""));
-
-            } else if (line.startsWith(QLatin1String(Constants::DISTRIB_CODENAME))) {
-                ver->m_codename = line.replace(QLatin1String(Constants::DISTRIB_CODENAME),QLatin1String(""));
-
-            } else if (line.startsWith(QLatin1String(Constants::DISTRIB_DESCRIPTION))) {
-                ver->m_description = line.replace(QLatin1String(Constants::DISTRIB_DESCRIPTION),QLatin1String(""));
+            if (line.startsWith(QLatin1String(DISTRIB_ID))) {
+                m_id = line.replace(QLatin1String(DISTRIB_ID),QLatin1String(""));
+
+            } else if (line.startsWith(QLatin1String(DISTRIB_RELEASE))) {
+                m_release = line.replace(QLatin1String(DISTRIB_RELEASE),QLatin1String(""));
+
+            } else if (line.startsWith(QLatin1String(DISTRIB_CODENAME))) {
+                m_codename = line.replace(QLatin1String(DISTRIB_CODENAME),QLatin1String(""));
+
+            } else if (line.startsWith(QLatin1String(DISTRIB_DESCRIPTION))) {
+                m_description = line.replace(QLatin1String(DISTRIB_DESCRIPTION),QLatin1String(""));
             }
         }
 
-        return ver;
+        m_valid = true;
     }
-    return 0;
 }
+
+}}
+

=== modified file 'src/ubuntu/ubuntuversion.h'
--- src/ubuntu/ubuntuversion.h	2014-05-27 15:53:25 +0000
+++ src/ubuntu/ubuntuversion.h	2016-11-16 10:23:00 +0000
@@ -27,28 +27,30 @@
 namespace Internal {
 
 
-class UbuntuVersion : public QObject
+class UbuntuVersion
 {
-    Q_OBJECT
-
 public:
     explicit UbuntuVersion();
     
 public slots:
-    QString id() { return m_id; }
-    QString release() { return m_release; }
-    QString codename() { return m_codename; }
-    QString description() { return m_description; }
-
-    Core::FeatureSet features();
-
-    static UbuntuVersion *fromLsbFile( const QString &fileName );
+    bool isValid () const { return m_valid; }
+    QString id() const { return m_id; }
+    QString release() const { return m_release; }
+    QString codename() const { return m_codename; }
+    QString description() const { return m_description; }
+    bool supportsSnappy () const;
+
+    static UbuntuVersion *instance( );
+
+protected:
+    void initFromLsbFile( );
 
 protected:
     QString m_id;
     QString m_release;
     QString m_codename;
     QString m_description;
+    bool m_valid = false;
 };
 }
 }