trying again on script loading changes

Seth Alves committed 10 years ago

Commit 35affe21 parent 0f288244 files · +67 −36Browse files

Showing the changes to libraries/script-engine/src/ScriptEngines.cpp (1 of 4 files). Show all

Unified · Split

libraries/script-engine/src/ScriptEngines.cpp+51−27

 QUrl normalizeScriptURL(const QUrl& rawScriptURL) {
     if (rawScriptURL.scheme() == "file") {
+        qDebug() << "+";
+        qDebug() << "+";
+        qDebug() << "+";
         QUrl fullNormal = rawScriptURL;
         QUrl defaultScriptLoc = defaultScriptsLocation();
-        #ifdef Q_OS_LINUX
+        // #ifdef Q_OS_LINUX
-        #else
+        // #else
-        // Force lowercase on file scripts because of drive letter weirdness.
+        // // Force lowercase on file scripts because of drive letter weirdness.
-        if (rawScriptURL.isLocalFile()) {
+        // if (rawScriptURL.isLocalFile()) {
-            fullNormal.setPath(fullNormal.path().toLower());
+        //     fullNormal.setPath(fullNormal.path()); // .toLower());
-        }
+        // }
-        #endif
+        // #endif
         // if this url is something "beneath" the default script url, replace the local path with ~
         if (fullNormal.scheme() == defaultScriptLoc.scheme() &&
             fullNormal.host() == defaultScriptLoc.host() &&
     }
 }
-QUrl expandScriptUrl(const QUrl& normalizedScriptURL) {
+QUrl expandScriptUrl(const QUrl& rawScriptURL) {
+    QUrl normalizedScriptURL = normalizeScriptURL(rawScriptURL);
+    qDebug() << "expandScriptUrl in = " << rawScriptURL;
     if (normalizedScriptURL.scheme() == "http" ||
         normalizedScriptURL.scheme() == "https" ||
         normalizedScriptURL.scheme() == "atp") {
+        qDebug() << "expandScriptUrl out(net) = " << normalizedScriptURL;
         return normalizedScriptURL;
     } else if (normalizedScriptURL.scheme() == "file") {
         if (normalizedScriptURL.path().startsWith("/~/")) {
             QUrl url = normalizedScriptURL;
+            qDebug() << "in expand, normalizedScriptURL = " << normalizedScriptURL;
             QStringList splitPath = url.path().split("/");
             QUrl defaultScriptsLoc = defaultScriptsLocation();
             url.setPath(defaultScriptsLoc.path() + "/" + splitPath.mid(2).join("/")); // 2 to skip the slashes in /~/
+            qDebug() << "expandScriptUrl out(file 0) = " << url;
             return url;
         }
+        qDebug() << "expandScriptUrl out(file 1) = " << normalizedScriptURL;
         return normalizedScriptURL;
     } else {
+        qDebug() << "expandScriptUrl out(bad scheme) = " << normalizedScriptURL;
         return QUrl("");
     }
 }
         }
         QVariantMap resultNode;
         resultNode.insert("name", runningScriptURL.fileName());
-        QUrl displayURL = expandScriptUrl(QUrl(runningScriptURL));
+        QUrl displayURL = expandScriptUrl(runningScriptURL);
         QString displayURLString;
         if (displayURL.isLocalFile()) {
             displayURLString = displayURL.toLocalFile();
         loadDefaultScripts();
         _firstRun.set(false);
         return;
     }
     // loads all saved scripts
     Settings settings;
 QStringList ScriptEngines::getRunningScripts() {
     QReadLocker lock(&_scriptEnginesHashLock);
-    return _scriptEnginesHash.keys();
+    QList<QUrl> urls = _scriptEnginesHash.keys();
+    QStringList result;
+    for (auto url : urls) {
+        result.append(url.toString());
+    }
+    return result;
 }
 void ScriptEngines::stopAllScripts(bool restart) {
     if (restart) {
         // Delete all running scripts from cache so that they are re-downloaded when they are restarted
         auto scriptCache = DependencyManager::get<ScriptCache>();
-        for (QHash<QString, ScriptEngine*>::const_iterator it = _scriptEnginesHash.constBegin();
+        for (QHash<QUrl, ScriptEngine*>::const_iterator it = _scriptEnginesHash.constBegin();
             it != _scriptEnginesHash.constEnd(); it++) {
             if (!it.value()->isFinished()) {
                 scriptCache->deleteScript(it.key());
     }
     // Stop and possibly restart all currently running scripts
-    for (QHash<QString, ScriptEngine*>::const_iterator it = _scriptEnginesHash.constBegin();
+    for (QHash<QUrl, ScriptEngine*>::const_iterator it = _scriptEnginesHash.constBegin();
         it != _scriptEnginesHash.constEnd(); it++) {
         if (it.value()->isFinished()) {
             continue;
         if (!scriptURL.isValid()) {
             scriptURL = normalizeScriptURL(QUrl::fromLocalFile(rawScriptURL));
         }
-        const QString scriptURLString = scriptURL.toString();
         QReadLocker lock(&_scriptEnginesHashLock);
-        if (_scriptEnginesHash.contains(scriptURLString)) {
+        if (_scriptEnginesHash.contains(scriptURL)) {
-            ScriptEngine* scriptEngine = _scriptEnginesHash[scriptURLString];
+            ScriptEngine* scriptEngine = _scriptEnginesHash[scriptURL];
             if (restart) {
                 auto scriptCache = DependencyManager::get<ScriptCache>();
-                scriptCache->deleteScript(QUrl(scriptURLString));
+                scriptCache->deleteScript(scriptURL);
                 connect(scriptEngine, &ScriptEngine::finished, this, [this](QString scriptName, ScriptEngine* engine) {
                     reloadScript(scriptName);
                 });
             }
             scriptEngine->stop();
             stoppedScript = true;
-            qCDebug(scriptengine) << "stopping script..." << scriptURLString;
+            qCDebug(scriptengine) << "stopping script..." << scriptURL;
         }
     }
     return stoppedScript;
     _scriptsModel.updateScriptsLocation(scriptsLocation);
 }
 void ScriptEngines::reloadAllScripts() {
     DependencyManager::get<ScriptCache>()->clearCache();
     emit scriptsReloading();
     stopAllScripts(true);
         scriptUrl = normalizeScriptURL(scriptFilename);
     }
-    auto scriptEngine = getScriptEngine(scriptUrl.toString());
+    auto scriptEngine = getScriptEngine(scriptUrl);
     if (scriptEngine) {
         return scriptEngine;
     }
     return scriptEngine;
 }
-ScriptEngine* ScriptEngines::getScriptEngine(const QString& rawScriptURL) {
+ScriptEngine* ScriptEngines::getScriptEngine(const QUrl& rawScriptURL) {
     ScriptEngine* result = nullptr;
     {
         QReadLocker lock(&_scriptEnginesHashLock);
-        const QString scriptURLString = normalizeScriptURL(QUrl(rawScriptURL)).toString();
+        const QUrl scriptURL = normalizeScriptURL(rawScriptURL);
-        auto it = _scriptEnginesHash.find(scriptURLString);
+        auto it = _scriptEnginesHash.find(scriptURL);
         if (it != _scriptEnginesHash.end()) {
             result = it.value();
         }
         QWriteLocker lock(&_scriptEnginesHashLock);
         QUrl url = QUrl(rawScriptURL);
         QUrl normalized = normalizeScriptURL(url);
-        const QString scriptURLString = normalized.toString();
+        _scriptEnginesHash.insertMulti(normalized, scriptEngine);
-        _scriptEnginesHash.insertMulti(scriptURLString, scriptEngine);
     }
     emit scriptCountChanged();
 }
     bool removed = false;
     {
         QWriteLocker lock(&_scriptEnginesHashLock);
-        const QString scriptURLString = normalizeScriptURL(QUrl(rawScriptURL)).toString();
+        const QUrl scriptURL = normalizeScriptURL(QUrl(rawScriptURL));
-        for (auto it = _scriptEnginesHash.find(scriptURLString); it != _scriptEnginesHash.end(); ++it) {
+        for (auto it = _scriptEnginesHash.find(scriptURL); it != _scriptEnginesHash.end(); ++it) {
             if (it.value() == engine) {
                 _scriptEnginesHash.erase(it);
                 removed = true;