eric: comparison Helpviewer/AdBlock/AdBlockSubscription.py

-:5522b3266c8b
+:02cf3bac079b
 @signal rulesChanged() emitted after the subscription's rules have changed
 """
 changed = pyqtSignal()
 rulesChanged = pyqtSignal()
-def __init__(self, url, parent=None, default=False):
+def __init__(self, url, custom, parent=None, default=False):
 """
 Constructor
 @param url AdBlock URL for the subscription (QUrl)
+@param custom flag indicating a custom subscription (boolean)
 @param parent reference to the parent object (QObject)
-@param default flag indicating a default subscription (Boolean)
+@param default flag indicating a default subscription (boolean)
 """
 super().__init__(parent)
+self.__custom = custom
 self.__url = url.toEncoded()
 self.__enabled = False
 self.__downloading = None
 self.__defaultSubscription = default
 self.__title = ""
 self.__location = QByteArray()
 self.__lastUpdate = QDateTime()
+self.__requiresLocation = ""
+self.__requiresTitle = ""
 self.__rules = []   # list containing all AdBlock rules
 self.__networkExceptionRules = []
 self.__networkBlockRules = []
+self.__domainRestrictedCssRules = []
+self.__elementHidingRules = ""
+self.__documentRules = []
+self.__elemhideRules = []
 self.__parseUrl(url)
 def __parseUrl(self, url):
 """
 self.__enabled = \
 QUrl.fromPercentEncoding(url.encodedQueryItemValue("enabled")) != "false"
 self.__location = \
 QByteArray(QUrl.fromPercentEncoding(url.encodedQueryItemValue("location")))
+# Check for required subscription
+self.__requiresLocation = \
+QUrl.fromPercentEncoding(url.encodedQueryItemValue("requiresLocation"))
+self.__requiresTitle = \
+QUrl.fromPercentEncoding(url.encodedQueryItemValue("requiresTitle"))
+if self.__requiresLocation and self.__requiresTitle:
+Helpviewer.HelpWindow.HelpWindow.adBlockManager().loadRequiredSubscription(
+self.__requiresLocation, self.__requiresTitle)
 lastUpdateByteArray = url.encodedQueryItemValue("lastUpdate")
 lastUpdateString = QUrl.fromPercentEncoding(lastUpdateByteArray)
 self.__lastUpdate = QDateTime.fromString(lastUpdateString, Qt.ISODate)
+##        if lastUpdateString:
+##            self.__lastUpdate = QDateTime.fromString(lastUpdateString, Qt.ISODate)
+##        else:
+##            self.__lastUpdate = QDateTime.currentDateTime()
 self.__loadRules()
 def url(self):
 """
 url.setPath("subscribe")
 queryItems = []
 queryItems.append(("location", bytes(self.__location).decode()))
 queryItems.append(("title", self.__title))
+if self.__requiresLocation and self.__requiresTitle:
+queryItems.append(("requiresLocation", self.__requiresLocation))
+queryItems.append(("requiresTitle", self.__requiresTitle))
 if not self.__enabled:
 queryItems.append(("enabled", "false"))
 if self.__lastUpdate.isValid():
 queryItems.append(("lastUpdate",
 self.__lastUpdate.toString(Qt.ISODate)))
 """
 if self.__enabled == enabled:
 return
 self.__enabled = enabled
-self.__populateCache()
-self.changed.emit()
 def title(self):
 """
 Public method to get the subscription title.
 return
 self.__location = url.toEncoded()
 self.__lastUpdate = QDateTime()
 self.changed.emit()
+def requiresLocation(self):
+"""
+Public method to get the location of a required subscription.
+@return location of a required subscription (string)
+"""
+return self.__requiresLocation
 def lastUpdate(self):
 """
 Public method to get the date and time of the last update.
 return
 if self.location().scheme() == "file":
 self.__lastUpdate = QDateTime.currentDateTime()
 self.__loadRules()
-self.changed.emit()
 return
 self.__downloading = FollowRedirectReply(self.location(),
 Helpviewer.HelpWindow.HelpWindow.networkAccessManager())
 self.__downloading.finished[()].connect(self.__rulesDownloaded)
 .file(fileName))
 return
 f.write(response)
 self.__lastUpdate = QDateTime.currentDateTime()
 self.__loadRules()
-self.changed.emit()
 self.__downloading = None
 def saveRules(self):
 """
 Public method to save the subscription rules.
 self.trUtf8("""Unable to open adblock file '{0}' for writing.""")\
 .format(fileName))
 return
 textStream = QTextStream(f)
-textStream << "[Adblock Plus 0.7.1]\n"
+textStream << "[Adblock Plus 1.1.1]\n"
 for rule in self.__rules:
 textStream << rule.filter() << "\n"
 def match(self, req, urlDomain, urlString):
 """
 if rule.matchDomain(domain):
 rules += rule.cssSelector() + ","
 return rules
+def rule(self, offset):
+"""
+Public method to get a specific rule.
+@param offset offset of the rule (integer)
+@return requested rule (AdBlockRule)
+"""
+if offset >= len(self.__rules):
+return None
+return self.__rules[offset]
 def allRules(self):
 """
 Public method to get the list of rules.
 @return list of rules (list of AdBlockRule)
 def addRule(self, rule):
 """
 Public method to add a rule.
 @param rule reference to the rule to add (AdBlockRule)
+@return offset of the rule (integer)
 """
 self.__rules.append(rule)
 self.__populateCache()
 self.rulesChanged.emit()
+return len(self.__rules) - 1
 def removeRule(self, offset):
 """
 Public method to remove a rule given the offset.
 """
 Public method to replace a rule given the offset.
 @param rule reference to the rule to set (AdBlockRule)
 @param offset offset of the rule to remove (integer)
-"""
+@return requested rule (AdBlockRule)
+"""
+if offset >= len(self.__rules):
+return None
 self.__rules[offset] = rule
 self.__populateCache()
 self.rulesChanged.emit()
+return self.__rules[offset]
 def __populateCache(self):
 """
 Private method to populate the various rule caches.
 """
 self.__elemhideRules.append(rule)
 elif rule.isException():
 self.__networkExceptionRules.append(rule)
 else:
 self.__networkBlockRules.append(rule)
+def canEditRules(self):
+"""
+Public method to check, if rules can be edited.
+@return flag indicating rules may be edited (boolean)
+"""
+return self.__custom
+def canBeRemoved(self):
+"""
+Public method to check, if the subscription can be removed.
+@return flag indicating removal is allowed (boolean)
+"""
+return not self.__custom and not self.__defaultSubscription
+def setRuleEnabled(self, offset, enabled):
+"""
+Public method to enable a specific rule.
+@param offset offset of the rule (integer)
+@param enabled new enabled state (boolean)
+@return reference to the changed rule (AdBlockRule)
+"""
+if offset >= len(self.__rules):
+return None
+rule = self.__rules[offset]
+rule.setEnabled(enabled)
+if rule.isCSSRule():
+self.__populateCache()
+Helpviewer.HelpWindow.HelpWindow.mainWindow().reloadUserStyleSheet()
+return rule

Mercurial Repositories > eric / file comparison

comparison: Helpviewer/AdBlock/AdBlockSubscription.py

Helpviewer/AdBlock/AdBlockSubscription.py