eric: comparison WebBrowser/GreaseMonkey/GreaseMonkeyScript.py

-:90c57b50600f
+:cbcca230679f
 """
 from __future__ import unicode_literals
 from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, QUrl, QRegExp, \
-QByteArray, QCryptographicHash
+QByteArray, QCryptographicHash, qVersion
 from PyQt5.QtWebEngineWidgets import QWebEngineScript
 from .GreaseMonkeyJavaScript import bootstrap_js, values_js
+from .GreaseMonkeyDownloader import GreaseMonkeyDownloader
 from ..Tools.DelayedFileWatcher import DelayedFileWatcher
 from ..WebBrowserPage import WebBrowserPage
 DocumentStart = 0
 DocumentEnd = 1
 DocumentIdle = 2
 scriptChanged = pyqtSignal()
+updatingChanged = pyqtSignal(bool)
 def __init__(self, manager, path):
 """
 Constructor
 self.__description = ""
 self.__version = ""
 self.__include = []
 self.__exclude = []
+self.__require = []
 self.__downloadUrl = QUrl()
 self.__updateUrl = QUrl()
 self.__startAt = GreaseMonkeyScript.DocumentEnd
 self.__fileName = path
 self.__enabled = True
 self.__valid = False
 self.__noFrames = False
+self.__updating = False
+self.__downloaders = []
 self.__parseScript()
 self.__fileWatcher.delayedFileChanged.connect(
 self.__watchedFileChanged)
 @return list of excluded URLs (list of strings)
 """
 return self.__exclude[:]
-def script(self):
+def require(self):
 """
-Public method to get the Javascript source.
+Public method to get the list of required scripts.
-@return Javascript source (string)
+@return list of required scripts (list of strings)
 """
-return self.__script
+return self.__require[:]
 def fileName(self):
 """
 Public method to get the path of the Javascript file.
-@return path path of the Javascript file (string)
+@return path of the Javascript file (string)
 """
 return self.__fileName
+def isUpdating(self):
+"""
+Public method to get the updating flag.
+@return updating flag
+@rtype bool
+"""
+return self.__updating
 @pyqtSlot(str)
 def __watchedFileChanged(self, fileName):
 """
 Private slot handling changes of the script file.
 @param fileName path of the script file
 @type str
 """
 if self.__fileName == fileName:
-self.__parseScript()
+self.__reloadScript()
-self.__manager.removeScript(self, False)
-self.__manager.addScript(self)
-self.scriptChanged.emit()
 def __parseScript(self):
 """
 Private method to parse the given script and populate the data
 structure.
 self.__description = ""
 self.__version = ""
 self.__include = []
 self.__exclude = []
+self.__require = []
 self.__downloadUrl = QUrl()
 self.__updateUrl = QUrl()
 self.__startAt = GreaseMonkeyScript.DocumentEnd
 if metaDataBlock == "":
 # invalid script file
 return
-requireList = []
 for line in metaDataBlock.splitlines():
 if not line.strip():
 continue
 if not line.startswith("// @"):
 elif key in ["@exclude", "@exclude_match"]:
 self.__exclude.append(value)
 elif key == "@require":
-requireList.append(value)
+self.__require.append(value)
 elif key == "@run-at":
 if value == "document-end":
 self.__startAt = GreaseMonkeyScript.DocumentEnd
 elif value == "document-start":
 nspace = bytes(QCryptographicHash.hash(
 QByteArray(self.fullName().encode("utf-8")),
 QCryptographicHash.Md4).toHex()).decode("ascii")
 valuesScript = values_js.format(nspace)
-runCheck = """
+if qVersion() < "5.8.0":
-for (var value of {0}) {{
+runCheck = """
-var re = new RegExp(value);
+for (var value of {0}) {{
-if (re.test(window.location.href)) {{
+var re = new RegExp(value);
+if (re.test(window.location.href)) {{
+return;
+}}
+}}
+__eric_includes = false;
+for (var value of {1}) {{
+var re = new RegExp(value);
+if (re.test(window.location.href)) {{
+__eric_includes = true;
+break;
+}}
+}}
+if (!__eric_includes) {{
 return;
 }}
-}}
+delete __eric_includes;""".format(
-__eric_includes = false;
+self.__toJavaScriptList(self.__exclude[:]),
-for (var value of {1}) {{
+self.__toJavaScriptList(self.__include[:])
-var re = new RegExp(value);
+)
-if (re.test(window.location.href)) {{
+self.__script = "(function(){{{0}\n{1}\n{2}\n{3}\n}})();".format(
-__eric_includes = true;
+runCheck, valuesScript,
-break;
+self.__manager.requireScripts(self.__require), fileData
-}}
+)
-}}
+else:
-if (!__eric_includes) {{
+self.__script = "(function(){{{0}\n{1}\n{2}\n}})();".format(
-return;
+valuesScript, self.__manager.requireScripts(self.__require),
-}}
+fileData
-delete __eric_includes;""".format(
+)
-self.__toJavaScriptList(self.__exclude[:]),
-self.__toJavaScriptList(self.__include[:])
-)
-runCheck = ""
-self.__script = "(function(){{{0}\n{1}\n{2}\n{3}\n}})();".format(
-runCheck, valuesScript,
-self.__manager.requireScripts(requireList), fileData
-)
 self.__valid = True
 def webScript(self):
 """
 Public method to create a script object.
 @return prepared script object
 @rtype QWebEngineScript
 @exception ValueError raised to indicate an unsupported start point
 """
-if self.startAt() == GreaseMonkeyScript.DocumentStart:
+if qVersion() < "5.8.0":
-injectionPoint = QWebEngineScript.DocumentCreation
+if self.startAt() == GreaseMonkeyScript.DocumentStart:
-elif self.startAt() == GreaseMonkeyScript.DocumentEnd:
+injectionPoint = QWebEngineScript.DocumentCreation
-injectionPoint = QWebEngineScript.DocumentReady
+elif self.startAt() == GreaseMonkeyScript.DocumentEnd:
-elif self.startAt() == GreaseMonkeyScript.DocumentIdle:
+injectionPoint = QWebEngineScript.DocumentReady
-injectionPoint = QWebEngineScript.Deferred
+elif self.startAt() == GreaseMonkeyScript.DocumentIdle:
-else:
+injectionPoint = QWebEngineScript.Deferred
-raise ValueError("Wrong script start point.")
+else:
+raise ValueError("Wrong script start point.")
 script = QWebEngineScript()
 script.setSourceCode("{0}\n{1}".format(
 bootstrap_js, self.__script
 ))
 script.setName(self.fullName())
-script.setInjectionPoint(injectionPoint)
+if qVersion() < "5.8.0":
+script.setInjectionPoint(injectionPoint)
 script.setWorldId(WebBrowserPage.SafeJsWorld)
 script.setRunsOnSubFrames(not self.__noFrames)
 return script
 def __toJavaScriptList(self, patterns):
 @param patterns list of match patterns
 @type list of str
 @return JavaScript script containing the list
 @rtype str
 """
-patternList = []
+if qVersion() >= "5.8.0":
-for pattern in patterns:
+script = ""
-if pattern.startswith("/") and pattern.endswith("/") and \
+else:
-len(pattern) > 1:
+patternList = []
-pattern = pattern[1:-1]
+for pattern in patterns:
-else:
+if pattern.startswith("/") and pattern.endswith("/") and \
-pattern = pattern.replace(".", "\\.").replace("*", ".*")
+len(pattern) > 1:
-pattern = "'{0}'".format(pattern)
+pattern = pattern[1:-1]
-patternList.append(pattern)
+else:
+pattern = pattern.replace(".", "\\.").replace("*", ".*")
-script = "[{0}]".format(",".join(patternList))
+pattern = "'{0}'".format(pattern)
+patternList.append(pattern)
+script = "[{0}]".format(",".join(patternList))
 return script
+def updateScript(self):
+"""
+Public method to updated the script.
+"""
+if not self.__downloadUrl.isValid() or self.__updating:
+return
+self.__updating = True
+self.updatingChanged.emit(self.__updating)
+downloader = GreaseMonkeyDownloader(
+self.__downloadUrl,
+self.__manager,
+GreaseMonkeyDownloader.DownloadMainScript)
+downloader.updateScript(self.__fileName)
+downloader.finished.connect(self.__downloaderFinished)
+downloader.error.connect(self.__downloaderError)
+self.__downloaders.append(downloader)
+self.__downloadRequires()
+def __downloaderFinished(self):
+"""
+Private slot to handle a finished download.
+"""
+downloader = self.sender()
+if downloader in self.__downloaders:
+self.__downloaders.remove(downloader)
+self.__updating = False
+self.updatingChanged.emit(self.__updating)
+def __downloaderError(self):
+"""
+Private slot to handle a downloader error.
+"""
+downloader = self.sender()
+if downloader in self.__downloaders:
+self.__downloaders.remove(downloader)
+self.__updating = False
+self.updatingChanged.emit(self.__updating)
+def __reloadScript(self):
+"""
+Private method to reload the script.
+"""
+self.__parseScript()
+self.__manager.removeScript(self, False)
+self.__manager.addScript(self)
+self.scriptChanged.emit()
+def __downloadRequires(self):
+"""
+Private method to download the required scripts.
+"""
+for urlStr in self.__require:
+if not self.__manager.requireScripts([urlStr]):
+downloader = GreaseMonkeyDownloader(
+QUrl(urlStr),
+self.__manager,
+GreaseMonkeyDownloader.DownloadRequireScript)
+downloader.finished.connect(self.__requireDownloaded)
+downloader.error.connect(self.__requireDownloadError)
+self.__downloaders.append(downloader)
+def __requireDownloaded(self):
+"""
+Private slot to handle a finished download of a required script.
+"""
+downloader = self.sender()
+if downloader in self.__downloaders:
+self.__downloaders.remove(downloader)
+self.__reloadScript()
+def __requireDownloadError(self):
+"""
+Private slot to handle a downloader error.
+"""
+downloader = self.sender()
+if downloader in self.__downloaders:
+self.__downloaders.remove(downloader)

Mercurial Repositories > eric / file comparison

comparison: WebBrowser/GreaseMonkey/GreaseMonkeyScript.py

WebBrowser/GreaseMonkey/GreaseMonkeyScript.py