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

[Benjamin Zeller]

- Add UbuntuCMakeCache
- Add support for UBUNTU_MANIFEST_PATH cache variable to support core
apps
- Fallback to search the manifest file in builddir if the desktop file
path in the project dir manifest file is not valid (core apps
compatibility)
- Fix bug lp:1358381 "new click-check-* scripts not shown in Validate
section of Ubuntu Publish"

- Add UbuntuCMakeCache
- Add support for UBUNTU_MANIFEST_PATH cache variable to support core
apps
- Fallback to search the manifest file in builddir if the desktop file
path in the project dir manifest file is not valid (core apps
compatibility)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:264
http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-ci/394/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-amd64-ci/162
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-armhf-ci/162

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtcreator-plugin-ubuntu-ci/394/rebuild

review: Approve (continuous-integration)

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

265. By Benjamin Zeller on 2014-08-20

Fix bug lp:1358381 "new click-check-* scripts not shown in Validate
section of Ubuntu Publish"

[Zoltan Balogh (bzoltan)]

OK

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:265
http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-ci/395/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-amd64-ci/163
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-armhf-ci/163

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtcreator-plugin-ubuntu-ci/395/rebuild

review: Approve (continuous-integration)

=== modified file 'src/ubuntu/ubuntu.pro'
--- src/ubuntu/ubuntu.pro	2014-08-18 12:29:43 +0000
+++ src/ubuntu/ubuntu.pro	2014-08-20 15:15:46 +0000
@@ -132,7 +132,8 @@
     ubuntuabstractguieditor.cpp \
     ubuntuabstractguieditordocument.cpp \
     ubuntuapparmoreditor.cpp \
-    ubuntueditorfactory.cpp
+    ubuntueditorfactory.cpp \
+    ubuntucmakecache.cpp
 
 HEADERS += \
     ubuntuplugin.h \
@@ -212,5 +213,6 @@
     ubuntuabstractguieditor.h \
     ubuntuabstractguieditordocument.h \
     ubuntuapparmoreditor.h \
-    ubuntueditorfactory.h
+    ubuntueditorfactory.h \
+    ubuntucmakecache.h
 

=== added file 'src/ubuntu/ubuntucmakecache.cpp'
--- src/ubuntu/ubuntucmakecache.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntucmakecache.cpp	2014-08-20 15:15:46 +0000
@@ -0,0 +1,129 @@
+#include "ubuntucmakecache.h"
+
+#include <projectexplorer/session.h>
+#include <projectexplorer/project.h>
+#include <projectexplorer/target.h>
+#include <projectexplorer/buildconfiguration.h>
+#include <cmakeprojectmanager/cmakeprojectconstants.h>
+
+#include <QRegularExpression>
+#include <QDir>
+
+namespace Ubuntu{
+namespace Internal {
+
+enum {
+    debug = 0
+};
+
+/*!
+ * \class UbuntuCMakeCache::UbuntuCMakeCache
+ * Automatic updating value cache, this reads all relevant CMakeCache files
+ * and stores some for quick querying
+ */
+
+UbuntuCMakeCache * UbuntuCMakeCache::m_instance = nullptr;
+
+UbuntuCMakeCache::UbuntuCMakeCache(QObject *parent) :
+    QObject(parent)
+{
+    Q_ASSERT_X(m_instance == nullptr,Q_FUNC_INFO,"There can be only one UbuntuCMakeCache instance");
+    m_instance = this;
+
+    connect(ProjectExplorer::SessionManager::instance(),SIGNAL(aboutToRemoveProject(ProjectExplorer::Project *)),
+            this,SLOT(onAboutToRemoveProject(ProjectExplorer::Project*)));
+}
+
+QVariant UbuntuCMakeCache::getValue(const QString &key, ProjectExplorer::BuildConfiguration *bc, const QVariant defaultValue)
+{
+    UbuntuCMakeCache *inst = instance();
+    if(!inst)
+        return defaultValue;
+
+    Utils::FileName cacheFile = bc->buildDirectory().appendPath(QStringLiteral("CMakeCache.txt"));
+    QString cacheKey = inst->normalize(cacheFile.toString());
+
+    bool needsRefresh = false;
+    if(!inst->m_map.contains(cacheKey)) {
+        //we need to read it
+        needsRefresh = true;
+    } else {
+        //check if the file has changed since the last read
+        inst->m_map[cacheKey].cacheFile.refresh();
+        if(debug) qDebug()<<"File Last Read "<<inst->m_map[cacheKey].cacheFile.lastModified()
+                         <<"Cache Last Read "<<inst->m_map[cacheKey].lastRead;
+        if(inst->m_map[cacheKey].cacheFile.lastModified() != inst->m_map[cacheKey].lastRead) {
+            needsRefresh = true;
+        }
+    }
+
+    if(needsRefresh)
+        inst->refreshCache(cacheKey, cacheFile);
+
+    if(inst->m_map[cacheKey].values.contains(key))
+        return inst->m_map[cacheKey].values[key];
+
+    return defaultValue;
+}
+
+UbuntuCMakeCache *UbuntuCMakeCache::instance()
+{
+    return m_instance;
+}
+
+void UbuntuCMakeCache::onAboutToRemoveProject(ProjectExplorer::Project *p)
+{
+    if(!p)
+        return;
+
+    //remove all values that belong to the project
+    for (ProjectExplorer::Target *t : p->targets()) {
+        for(ProjectExplorer::BuildConfiguration *bc : t->buildConfigurations()) {
+            Utils::FileName cacheFile = bc->buildDirectory().appendPath(QStringLiteral("CMakeCache.txt"));
+            m_map.remove(normalize(cacheFile.toString()));
+        }
+    }
+}
+
+QString UbuntuCMakeCache::normalize(const QString &path) const
+{
+    return QDir::cleanPath(path);
+}
+
+void UbuntuCMakeCache::refreshCache(const QString &key, const Utils::FileName &fName)
+{
+    if(debug) qDebug()<<"Rebuilding cache for: "<<key;
+    UbuntuCMakeCacheEntry *entry = nullptr;
+    if(m_map.contains(key)) {
+        entry = &m_map[key];
+        entry->lastRead = fName.toFileInfo().lastModified();
+    } else {
+        QFileInfo fInfo = fName.toFileInfo();
+        entry = &m_map.insert(key,UbuntuCMakeCacheEntry{fInfo,fInfo.lastModified(),CMakeCacheValueMap()}).value();
+    }
+
+    QFile cache(fName.toString());
+    if(cache.exists() && cache.open(QIODevice::ReadOnly)) {
+        static const QRegularExpression regExpPType(QLatin1String("^UBUNTU_PROJECT_TYPE:(.*)=\\s*(\\S*)\\s*$"));
+        static const QRegularExpression regExpManifestPath (QLatin1String("^UBUNTU_MANIFEST_PATH:(.*)=\\s*(\\S*)\\s*$"));
+        QTextStream in(&cache);
+        while (!in.atEnd()) {
+            QString contents = in.readLine();
+            QRegularExpressionMatch m = regExpPType.match(contents);
+            if(m.hasMatch()) {
+                entry->values.insert(QStringLiteral("UBUNTU_PROJECT_TYPE"),m.captured(2));
+                continue;
+            }
+            m = regExpManifestPath.match(contents);
+            if(m.hasMatch()) {
+                entry->values.insert(QStringLiteral("UBUNTU_MANIFEST_PATH"),m.captured(2));
+                continue;
+            }
+        }
+
+
+    }
+}
+
+}}
+

=== added file 'src/ubuntu/ubuntucmakecache.h'
--- src/ubuntu/ubuntucmakecache.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntucmakecache.h	2014-08-20 15:15:46 +0000
@@ -0,0 +1,58 @@
+#ifndef UBUNTUCMAKECACHE_H
+#define UBUNTUCMAKECACHE_H
+
+#include <QObject>
+#include <QHash>
+#include <QMap>
+#include <QVariant>
+#include <QDateTime>
+#include <QFileInfo>
+
+#include <utils/fileutils.h>
+
+namespace ProjectExplorer {
+    class Project;
+    class Target;
+    class BuildConfiguration;
+}
+
+namespace Ubuntu{
+namespace Internal {
+
+typedef QMap<QString,QVariant> CMakeCacheValueMap;
+
+struct UbuntuCMakeCacheEntry {
+    QFileInfo cacheFile;
+    QDateTime lastRead;
+    CMakeCacheValueMap values;
+};
+
+typedef QMap<QString,UbuntuCMakeCacheEntry> CMakeCache;
+
+class UbuntuCMakeCache : public QObject
+{
+    Q_OBJECT
+public:
+    explicit UbuntuCMakeCache(QObject *parent = 0);
+
+    static QVariant getValue (const QString &key, ProjectExplorer::BuildConfiguration *bc, const QVariant defaultValue = QVariant());
+    static UbuntuCMakeCache *instance();
+
+private slots:
+    void onAboutToRemoveProject (ProjectExplorer::Project *p);
+
+private:
+    QString normalize (const QString &path) const;
+    void refreshCache (const QString &key, const Utils::FileName &fName);
+
+private:
+    CMakeCache m_map;
+    static UbuntuCMakeCache *m_instance;
+
+};
+
+}}
+
+
+
+#endif // UBUNTUCMAKECACHE_H

=== modified file 'src/ubuntu/ubuntulocalrunconfiguration.cpp'
--- src/ubuntu/ubuntulocalrunconfiguration.cpp	2014-08-14 18:41:49 +0000
+++ src/ubuntu/ubuntulocalrunconfiguration.cpp	2014-08-20 15:15:46 +0000
@@ -21,6 +21,7 @@
 #include "ubuntuprojectguesser.h"
 #include "ubuntuclickmanifest.h"
 #include "ubunturemoterunconfiguration.h"
+#include "ubuntucmakecache.h"
 
 #include <qtsupport/baseqtversion.h>
 #include <qtsupport/qtkitinformation.h>
@@ -144,18 +145,34 @@
         };
 
         //first lets check if the informations in the manifest file are helpful
-        QFileInfo manifestFile(projectDir.appendPath(QStringLiteral("manifest.json")).toString());
-        if ( manifestFile.exists() ) {
-            UbuntuClickManifest manifest;
-            if(manifest.load(manifestFile.absoluteFilePath())){
-                QString desktop = getDesktopFromManifest(manifest);
-
-                if(!desktop.isEmpty()) {
-                    QFileInfo d(desktop);
-
-                    desktop = searchDesktopFile(d.fileName());
-                    if(!desktop.isEmpty())
-                        return desktop;
+        QVariant manifestPath = UbuntuCMakeCache::getValue(QStringLiteral("UBUNTU_MANIFEST_PATH"),
+                                                           config->target()->activeBuildConfiguration(),
+                                                           QStringLiteral("manifest.json"));
+
+
+        //search for the manifest file in the project dir AND in the builddir
+        QList<Utils::FileName> searchPaths{
+            projectDir.appendPath(manifestPath.toString()),
+            config->target()->activeBuildConfiguration()->buildDirectory()
+                    .appendPath(QFileInfo(manifestPath.toString()).path())
+                    .appendPath(QStringLiteral("manifest.json"))
+        };
+
+        for(Utils::FileName path : searchPaths) {
+            QFileInfo manifestFile(path.toString());
+            if(debug) qDebug()<<"Searching for the manifest file: "<<manifestFile.absoluteFilePath();
+            if ( manifestFile.exists() ) {
+                UbuntuClickManifest manifest;
+                if(manifest.load(manifestFile.absoluteFilePath())){
+                    QString desktop = getDesktopFromManifest(manifest);
+
+                    if(!desktop.isEmpty()) {
+                        QFileInfo d(desktop);
+
+                        desktop = searchDesktopFile(d.fileName());
+                        if(!desktop.isEmpty())
+                            return desktop;
+                    }
                 }
             }
         }
@@ -193,7 +210,7 @@
 
         return QString();
     }
-    manifestPath = package_dir.absoluteFilePath(QLatin1String("manifest.json"));
+    manifestPath = package_dir.absoluteFilePath(QStringLiteral("manifest.json"));
 
     //read the manifest
     UbuntuClickManifest manifest;

=== modified file 'src/ubuntu/ubuntulocalrunconfigurationfactory.cpp'
--- src/ubuntu/ubuntulocalrunconfigurationfactory.cpp	2014-08-18 15:52:52 +0000
+++ src/ubuntu/ubuntulocalrunconfigurationfactory.cpp	2014-08-20 15:15:46 +0000
@@ -22,6 +22,8 @@
 #include "ubuntudevice.h"
 #include "clicktoolchain.h"
 #include "ubuntuclickmanifest.h"
+#include "ubuntucmakecache.h"
+
 #include <cmakeprojectmanager/cmakeproject.h>
 #include <cmakeprojectmanager/cmakeprojectconstants.h>
 
@@ -63,7 +65,11 @@
             return types;
     }
 
-    QString manifestPath = QStringLiteral("%1/manifest.json").arg(parent->project()->projectDirectory());
+    QString manifestPath = QDir::cleanPath(parent->project()->projectDirectory()
+                                           +QDir::separator()
+                                           +UbuntuCMakeCache::getValue(QStringLiteral("UBUNTU_MANIFEST_PATH"),
+                                                                       parent->activeBuildConfiguration(),
+                                                                       QStringLiteral("manifest.json")).toString());
     UbuntuClickManifest manifest;
 
     //if we have no manifest, we can not query the app id's

=== modified file 'src/ubuntu/ubuntumenu.h'
--- src/ubuntu/ubuntumenu.h	2014-08-19 09:50:02 +0000
+++ src/ubuntu/ubuntumenu.h	2014-08-20 15:15:46 +0000
@@ -89,7 +89,6 @@
     bool isProperUbuntuHtmlProject(ProjectExplorer::Project *project) const;
     static UbuntuMenu *m_instance;
     QPointer<ProjectExplorer::Project> m_ctxMenuProject;
-
 };
 
 

=== modified file 'src/ubuntu/ubuntupackagestep.cpp'
--- src/ubuntu/ubuntupackagestep.cpp	2014-08-14 18:41:49 +0000
+++ src/ubuntu/ubuntupackagestep.cpp	2014-08-20 15:15:46 +0000
@@ -473,9 +473,6 @@
         QFile::remove(debTargetPath);
 
     if( injectDebugScript && ubuntuDevice ) {
-
-        QString projectName = target()->project()->displayName();
-
         QRegularExpression deskExecRegex(QStringLiteral("^(\\s*[Ee][Xx][Ee][cC]=.*)$"),QRegularExpression::MultilineOption);
 
         UbuntuClickManifest manifest;

=== modified file 'src/ubuntu/ubuntupackagingwidget.cpp'
--- src/ubuntu/ubuntupackagingwidget.cpp	2014-08-19 10:11:23 +0000
+++ src/ubuntu/ubuntupackagingwidget.cpp	2014-08-20 15:15:46 +0000
@@ -27,6 +27,7 @@
 #include "ubuntudevice.h"
 #include "ubuntupackagestep.h"
 #include "ubuntushared.h"
+#include "ubuntucmakecache.h"
 
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/project.h>
@@ -116,9 +117,11 @@
 
     ProjectExplorer::Project* startupProject = ProjectExplorer::SessionManager::startupProject();
 
-    //@TODO this could fail if the manifest file is not named correctly
+    QVariant manifestPath = UbuntuCMakeCache::getValue(QStringLiteral("UBUNTU_MANIFEST_PATH"),
+                                                       startupProject->activeTarget()->activeBuildConfiguration(),
+                                                       QStringLiteral("manifest.json"));
     UbuntuClickManifest manifest;
-    if(!manifest.load(startupProject->projectDirectory()+QDir::separator()+QStringLiteral("manifest.json")))
+    if(!manifest.load(startupProject->projectDirectory()+QDir::separator()+manifestPath.toString()))
         return;
 
     QString sClickPackageName;

=== modified file 'src/ubuntu/ubuntuplugin.cpp'
--- src/ubuntu/ubuntuplugin.cpp	2014-08-19 09:50:02 +0000
+++ src/ubuntu/ubuntuplugin.cpp	2014-08-20 15:15:46 +0000
@@ -40,6 +40,7 @@
 #include "ubuntuqmlbuildconfiguration.h"
 #include "ubuntufirstrunwizard.h"
 #include "ubuntueditorfactory.h"
+#include "ubuntucmakecache.h"
 
 #include <coreplugin/modemanager.h>
 #include <projectexplorer/kitmanager.h>
@@ -140,6 +141,7 @@
     addAutoReleasedObject(new ClickToolChainFactory);
     addAutoReleasedObject(new UbuntuCMakeToolFactory);
     addAutoReleasedObject(new UbuntuCMakeMakeStepFactory);
+    addAutoReleasedObject(new UbuntuCMakeCache);
     addAutoReleasedObject(new UbuntuCMakeBuildConfigurationFactory);
     addAutoReleasedObject(new UbuntuHtmlBuildConfigurationFactory);
     addAutoReleasedObject(new UbuntuQmlBuildConfigurationFactory);

=== modified file 'src/ubuntu/ubuntuprojectguesser.cpp'
--- src/ubuntu/ubuntuprojectguesser.cpp	2014-07-07 06:33:37 +0000
+++ src/ubuntu/ubuntuprojectguesser.cpp	2014-08-20 15:15:46 +0000
@@ -16,6 +16,7 @@
  * Author: Benjamin Zeller <[e-mail]>
  */
 #include "ubuntuprojectguesser.h"
+#include "ubuntucmakecache.h"
 
 #include <projectexplorer/project.h>
 #include <projectexplorer/target.h>
@@ -213,21 +214,9 @@
     if(project->activeTarget()
             && project->activeTarget()->activeBuildConfiguration())
     {
-        QFile cache(project->activeTarget()->activeBuildConfiguration()->buildDirectory().toString()
-                    + QDir::separator()
-                    + QLatin1String("CMakeCache.txt"));
-
-        if(cache.exists() && cache.open(QIODevice::ReadOnly)) {
-            QRegularExpression regExp(QLatin1String("^UBUNTU_PROJECT_TYPE:(.*)=\\s*(\\S*)\\s*$"));
-            QTextStream in(&cache);
-            while (!in.atEnd()) {
-                QString contents = in.readLine();
-                QRegularExpressionMatch m = regExp.match(contents);
-                if(m.hasMatch()) {
-                    return m.captured(2);
-                }
-            }
-        }
+        QVariant val = UbuntuCMakeCache::getValue(QStringLiteral("UBUNTU_PROJECT_TYPE"),project->activeTarget()->activeBuildConfiguration());
+        if(val.isValid())
+            return val.toString();
     }
 
     QFile projectFile(project->projectFilePath());

=== modified file 'src/ubuntu/ubuntuvalidationresultmodel.cpp'
--- src/ubuntu/ubuntuvalidationresultmodel.cpp	2014-06-02 09:48:49 +0000
+++ src/ubuntu/ubuntuvalidationresultmodel.cpp	2014-08-20 15:15:46 +0000
@@ -25,6 +25,7 @@
 #include <QStringList>
 #include <QVariant>
 #include <QIcon>
+#include <QDir>
 
 
 namespace Ubuntu {
@@ -235,6 +236,7 @@
 
 }
 
+
 /*!
  * \brief ClickRunChecksParser::beginRecieveData
  * Clear alls internal data and starts a completely new parse
@@ -285,7 +287,7 @@
  */
 bool ClickRunChecksParser::tryParseNextSection(bool dataComplete)
 {
-    QRegularExpression re(QLatin1String("^([=]+[\\s]+[A-Za-z0-9\\-_]+[\\s]+[=]+)$")); // match section beginnings
+    QRegularExpression re(QStringLiteral("^([=]+[\\s]+[A-Za-z0-9\\-_]+[\\s]+[=]+)$")); // match section beginnings
     re.setPatternOptions(QRegularExpression::MultilineOption);
 
     QRegularExpressionMatchIterator matchIter = re.globalMatch(m_data,m_nextSectionOffset);
@@ -314,10 +316,8 @@
     type.remove(QLatin1String("="));
     type = type.trimmed();
 
-    if(type == QLatin1String("click-check-lint")
-            || type == QLatin1String("click-check-desktop")
-            || type == QLatin1String("click-check-security")
-            || type == QLatin1String("click-check-functional")) {
+    static const QRegularExpression regExp(QStringLiteral("^(click-check-.*)"));
+    if(regExp.match(type).hasMatch()) {
         parseJsonSection(type,startOffset,(endOffset-startOffset)+1);
     } else {
         //ignore unknown sections

=== modified file 'src/ubuntu/ubuntuvalidationresultmodel.h'
--- src/ubuntu/ubuntuvalidationresultmodel.h	2014-04-10 10:56:24 +0000
+++ src/ubuntu/ubuntuvalidationresultmodel.h	2014-08-20 15:15:46 +0000
@@ -68,7 +68,6 @@
     void parsedNewTopLevelItem (DataItem* item);
 private:
     QString m_data;
-
     int     m_nextSectionOffset;
     int     m_errorCount;
     int     m_warnCount;