eric: comparison WebBrowser/AdBlock/AdBlockManager.py

-:8dba5fb92f12
+:19dff9c9cf26
 from __future__ import unicode_literals
 import os
-from PyQt5.QtCore import pyqtSignal, QObject, QUrl, QFile
+from PyQt5.QtCore import pyqtSignal, QObject, QUrl, QUrlQuery, QFile, \
+QByteArray
+from PyQt5.QtWebEngineCore import QWebEngineUrlRequestInfo
+from E5Gui import E5MessageBox
 from .AdBlockSubscription import AdBlockSubscription
+from .AdBlockUrlInterceptor import AdBlockUrlInterceptor
 from Utilities.AutoSaver import AutoSaver
 import Utilities
 import Preferences
 "title=EasyList"
 self.__customSubscriptionUrlString = \
 bytes(self.__customSubscriptionUrl().toEncoded()).decode()
 self.rulesChanged.connect(self.__saveTimer.changeOccurred)
+self.rulesChanged.connect(self.__rulesChanged)
+self.__interceptor = AdBlockUrlInterceptor(self)
+from WebBrowser.WebBrowserWindow import WebBrowserWindow
+WebBrowserWindow.networkManager().installUrlInterceptor(
+self.__interceptor)
+def __rulesChanged(self):
+"""
+Private slot handling a change of the AdBlock rules.
+"""
+from WebBrowser.WebBrowserWindow import WebBrowserWindow
+WebBrowserWindow.mainWindow().reloadUserStyleSheet()
 def close(self):
 """
 Public method to close the open search engines manager.
 """
 for mainWindow in WebBrowserWindow.mainWindows():
 mainWindow.adBlockIcon().setEnabled(enabled)
 if enabled:
 self.__loadSubscriptions()
 self.rulesChanged.emit()
-##
-##    def network(self):
+def block(self, info):
-##        """
+"""
-##        Public method to get a reference to the network block object.
+Public method to check, if a request should be blocked.
-##
-##        @return reference to the network block object (AdBlockNetwork)
+@param info request info aobject
-##        """
+@type QWebEngineUrlRequestInfo
-##        if self.__adBlockNetwork is None:
+@return flag indicating to block the request
-##            from .AdBlockNetwork import AdBlockNetwork
+@rtype bool
-##            self.__adBlockNetwork = AdBlockNetwork(self)
+"""
-##        return self.__adBlockNetwork
+urlString = bytes(info.requestUrl().toEncoded()).decode().lower()
+urlDomain = info.requestUrl().host().lower()
+urlScheme = info.requestUrl().scheme().lower()
+refererHost = info.firstPartyUrl().host().lower()
+if not self.isEnabled() or not self.__canRunOnScheme(urlScheme):
+return False
+if self.isHostExcepted(urlDomain) or self.isHostExcepted(refererHost):
+return False
+res = False
+for subscription in self.subscriptions():
+if subscription.isEnabled():
+if subscription.adBlockDisabledForUrl(info.requestUrl()):
+continue
+blockedRule = subscription.match(info, urlDomain, urlString)
+if blockedRule:
+res = True
+if info.resourceType() == \
+QWebEngineUrlRequestInfo.ResourceTypeMainFrame:
+url = QUrl("eric:adblock")
+query = QUrlQuery()
+query.addQueryItem("rule", blockedRule.filter())
+query.addQueryItem(
+"subscription", blockedRule.subscription().title())
+url.setQuery(query)
+info.redirect(url)
+res = False
+else:
+info.block(True)
+break
+return res
+def __canRunOnScheme(self, scheme):
+"""
+Private method to check, if AdBlock can be performed on the scheme.
+@param scheme scheme to check (string)
+@return flag indicating, that AdBlock can be performed (boolean)
+"""
+return scheme not in ["data", "eric", "qthelp", "qrc", "file", "abp"]
 def page(self):
 """
 Public method to get a reference to the page block object.
 self.removeSubscription(requiresSubscription, False)
 if emitSignal:
 self.rulesChanged.emit()
 except ValueError:
 pass
+def addSubscriptionFromUrl(self, url):
+"""
+Public method to ad an AdBlock subscription given the abp URL:
+@param url URL to subscribe an AdBlock subscription
+@type QUrl
+@return flag indicating success
+@rtype bool
+"""
+if url.path() != "subscribe":
+return False
+title = QUrl.fromPercentEncoding(
+QByteArray(QUrlQuery(url).queryItemValue("title").encode()))
+if not title:
+return False
+res = E5MessageBox.yesNo(
+None,
+self.tr("Subscribe?"),
+self.tr(
+"""<p>Subscribe to this AdBlock subscription?</p>"""
+"""<p>{0}</p>""").format(title))
+if res:
+from .AdBlockSubscription import AdBlockSubscription
+from WebBrowser.WebBrowserWindow import WebBrowserWindow
+dlg = WebBrowserWindow.adBlockManager().showDialog()
+subscription = AdBlockSubscription(
+url, False,
+WebBrowserWindow.adBlockManager())
+WebBrowserWindow.adBlockManager().addSubscription(subscription)
+dlg.addSubscription(subscription, False)
+dlg.setFocus()
+dlg.raise_()
 def addSubscription(self, subscription):
 """
 Public method to add an AdBlock subscription.
 return
 self.__loaded = True
 self.__enabled = Preferences.getWebBrowser("AdBlockEnabled")
+##    if (!m_enabled) {
+##        mApp->networkManager()->removeUrlInterceptor(m_interceptor);
+##        return;
+##    }
 if self.__enabled:
 self.__loadSubscriptions()
+##    mApp->networkManager()->installUrlInterceptor(m_interceptor);
 def __loadSubscriptions(self):
 """
 Private method to load the set of subscriptions.
 """
 self.__adBlockDialog = AdBlockDialog()
 self.__adBlockDialog.show()
 return self.__adBlockDialog
-def showRule(self):
-"""
-Public slot to show an AdBlock rule.
-"""
-act = self.sender()
-if act is not None:
-rule = act.data()
-if rule:
-self.showDialog().showRule(rule)
 def elementHidingRules(self):
 """
 Public method to get the element hiding rules.
 @return element hiding rules (string)
 """
-if not self.__enabled:
+if not self.isEnabled():
 return ""
 rules = ""
 for subscription in self.__subscriptions:
 Public method to get the element hiding rules for a domain.
 @param url URL to get hiding rules for (QUrl)
 @return element hiding rules (string)
 """
-if not self.__enabled:
+if not self.isEnabled():
 return ""
 rules = ""
 for subscription in self.__subscriptions:
 """
 Public method to set the list of excepted hosts.
 @param hosts list of excepted hosts (list of string)
 """
-self.__exceptedHosts = hosts[:]
+self.__exceptedHosts = [host.lower() for host in hosts]
 Preferences.setWebBrowser("AdBlockExceptions", self.__exceptedHosts)
 def addException(self, host):
 """
 Public method to add an exception.
 @param host to be excepted (string)
 """
+host = host.lower()
 if host and host not in self.__exceptedHosts:
 self.__exceptedHosts.append(host)
 Preferences.setWebBrowser(
 "AdBlockExceptions", self.__exceptedHosts)
 """
 Public method to remove an exception.
 @param host to be removed from the list of exceptions (string)
 """
+host = host.lower()
 if host in self.__exceptedHosts:
 self.__exceptedHosts.remove(host)
 Preferences.setWebBrowser(
 "AdBlockExceptions", self.__exceptedHosts)
 Public slot to check, if a host is excepted.
 @param host host to check (string)
 @return flag indicating an exception (boolean)
 """
+host = host.lower()
 return host in self.__exceptedHosts
 def showExceptionsDialog(self):
 """
 Public method to show the AdBlock Exceptions dialog.

Mercurial Repositories > eric / file comparison

comparison: WebBrowser/AdBlock/AdBlockManager.py

WebBrowser/AdBlock/AdBlockManager.py