FilterEngine API improvements

src/FilterEngine.cpp

+#include <algorithm>
 #include <AdblockPlus.h>
 
 using namespace AdblockPlus;
 
 #if !FILTER_ENGINE_STUBS
 extern const char* jsSources[];
 #endif
 
-Subscription::Subscription(const std::string& url, const std::string& title)
-  : url(url), title(title)
+#if FILTER_ENGINE_STUBS
+JSObject::JSObject(FilterEngine& filterEngine)
+    : filterEngine(filterEngine)
+{
+}
+#else
+JSObject::JSObject()
+{
+}
+#endif
+
+std::string JSObject::GetProperty(const std::string& name, const std::string& defaultValue) const
+{
+#if FILTER_ENGINE_STUBS
+  std::map<std::string, std::string>::const_iterator it = stringProperties.find(name);
+  if (it == stringProperties.end())
+    return defaultValue;
+  else
+    return it->second;
+#endif
+}
+
+int JSObject::GetProperty(const std::string& name, int defaultValue) const
+{
+#if FILTER_ENGINE_STUBS
+  std::map<std::string, int>::const_iterator it = intProperties.find(name);
+  if (it == intProperties.end())
+    return defaultValue;
+  else
+    return it->second;
+#endif
+}
+
+bool JSObject::GetProperty(const std::string& name, bool defaultValue) const
+{
+#if FILTER_ENGINE_STUBS
+  std::map<std::string, bool>::const_iterator it = boolProperties.find(name);
+  if (it == boolProperties.end())
+    return defaultValue;
+  else
+    return it->second;
+#endif
+}
+
+void JSObject::SetProperty(const std::string& name, const std::string& value)
+{
+#if FILTER_ENGINE_STUBS
+  stringProperties[name] = value;
+#endif
+}
+
+void JSObject::SetProperty(const std::string& name, int value)
+{
+#if FILTER_ENGINE_STUBS
+  intProperties[name] = value;
+#endif
+}
+
+void JSObject::SetProperty(const std::string& name, bool value)
+{
+#if FILTER_ENGINE_STUBS
+  boolProperties[name] = value;
+#endif
+}
+
+#if FILTER_ENGINE_STUBS
+Filter::Filter(FilterEngine& filterEngine, const std::string& text)
+    : JSObject(filterEngine)
+{
+  SetProperty("text", text);
+  if (text.find("!") == 0)
+    SetProperty("type", "comment");

[Felix Dahlke, 2013/04/06 05:17:05]

Have you considered having an enum for the type? Would mean we'd have to touch
this if we added new types of course.

+  else if (text.find("@@") == 0)
+    SetProperty("type", "exception");
+  else if (text.find("#@") != std::string::npos)
+    SetProperty("type", "elemhideexception");
+  else if (text.find("#") != std::string::npos)
+    SetProperty("type", "elemhide");
+  else
+    SetProperty("type", "blocking");
+}
+#else
+Filter::Filter()
+{
+}
+#endif
+
+bool Filter::IsListed() const
+{
+#if FILTER_ENGINE_STUBS
+  for (std::vector<Filter*>::iterator it = filterEngine.listedFilters.begin();
+       it != filterEngine.listedFilters.end(); ++it)
+  {
+    if (*it == this)
+      return true;
+  }
+  return false;
+#endif
+}
+
+void Filter::AddToList()
+{
+#if FILTER_ENGINE_STUBS
+  if (!IsListed())
+    filterEngine.listedFilters.push_back(this);
+#endif
+}
+
+void Filter::RemoveFromList()
+{
+  for (std::vector<Filter*>::iterator it = filterEngine.listedFilters.begin();
+       it != filterEngine.listedFilters.end();)
+  {
+    if (*it == this)
+      it = filterEngine.listedFilters.erase(it);
+    else
+      it++;
+  }
+}
+
+#if FILTER_ENGINE_STUBS
+Subscription::Subscription(FilterEngine& filterEngine, const std::string& url)
+    : JSObject(filterEngine)
+{
+  SetProperty("url", url);
+}
+#else
+Subscription::Subscription()
+{
+}
+#endif
+
+bool Subscription::IsListed() const
+{
+#if FILTER_ENGINE_STUBS
+  for (std::vector<Subscription*>::iterator it = filterEngine.listedSubscriptions.begin();
+       it != filterEngine.listedSubscriptions.end(); ++it)
+  {
+    if (*it == this)
+      return true;
+  }
+  return false;
+#endif
+}
+
+void Subscription::AddToList()
+{
+#if FILTER_ENGINE_STUBS
+  if (!IsListed())
+    filterEngine.listedSubscriptions.push_back(this);
+#endif
+}
+
+void Subscription::RemoveFromList()
+{
+  for (std::vector<Subscription*>::iterator it = filterEngine.listedSubscriptions.begin();
+       it != filterEngine.listedSubscriptions.end();)
+  {
+    if (*it == this)
+      it = filterEngine.listedSubscriptions.erase(it);
+    else
+      it++;
+  }
+}
+
+void Subscription::UpdateFilters()
 {
 }
 
 FilterEngine::FilterEngine(JsEngine& jsEngine) : jsEngine(jsEngine)
 {
 #if !FILTER_ENGINE_STUBS
   for (int i = 0; jsSources[i] && jsSources[i + 1]; i += 2)
     jsEngine.Evaluate(jsSources[i + 1], jsSources[i]);
 #endif
 }
 
-void FilterEngine::AddSubscription(Subscription subscription)
-{
-  subscriptions.push_back(subscription);
-}
-
-void FilterEngine::RemoveSubscription(const Subscription& subscription)
-{
-  for (std::vector<Subscription>::iterator it = subscriptions.begin();
-       it != subscriptions.end();)
-    if (it->url == subscription.url)
-      it = subscriptions.erase(it);
-    else
-      it++;
-}
-
-const Subscription* FilterEngine::FindSubscription(const std::string& url) const
-{
-  for (std::vector<Subscription>::const_iterator it = subscriptions.begin();
-       it != subscriptions.end(); it++)
-    if (it->url == url)
-      return &(*it);
-  return 0;
-}
-
-const std::vector<Subscription>& FilterEngine::GetSubscriptions() const
-{
-  return subscriptions;
-}
-
-void FilterEngine::UpdateSubscriptionFilters(const Subscription& subscription)
-{
-}
-
-std::vector<Subscription> FilterEngine::FetchAvailableSubscriptions()
-{
-  std::vector<Subscription> availableSubscriptions;
-  availableSubscriptions.push_back(Subscription("https://easylist-downloads.adblockplus.org/easylist.txt", "EasyList"));
-  availableSubscriptions.push_back(Subscription("https://easylist-downloads.adblockplus.org/easylistgermany+easylist.txt", "EasyList Germany+EasyList"));
-  return availableSubscriptions;
-}
-
-bool FilterEngine::Matches(const std::string& url,
-                           const std::string& contentType) const
-{
+Filter& FilterEngine::GetFilter(const std::string& text)
+{
+#if FILTER_ENGINE_STUBS
+  // Via http://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring
+  std::string trimmed(text);
+  trimmed.erase(trimmed.begin(), std::find_if(trimmed.begin(), trimmed.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
+  trimmed.erase(std::find_if(trimmed.rbegin(), trimmed.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), trimmed.end());
+
+  std::map<std::string, Filter*>::const_iterator it = knownFilters.find(trimmed);
+  if (it != knownFilters.end())
+    return *it->second;
+
+  Filter* result = new Filter(*this, trimmed);
+  knownFilters[trimmed] = result;

[Oleksandr, 2013/04/05 14:09:07]

I was not able to understand who and when is doing (or is meant to be doing) the
deletion of this Filter* result. Can you please elaborate? 

[Wladimir Palant, 2013/04/05 14:31:45]

The C++ wrappers are cached for the entire life time of the process - same as
their JavaScript counterparts. The size of the C++ wrapper should be negligible
compared to the JS object it is wrapping so I'm not sure doing something that's
more smart is actually worth it.

[Oleksandr, 2013/04/05 15:14:12]

So I take it as no one deletes it - it is just cleaned up by the system when the
process quits, correct? I personally would just put a loop in FilterEngine's
destructor that would iterate through knownFilters and delete each. 

On 2013/04/05 14:31:45, Wladimir Palant wrote:

[Felix Dahlke, 2013/04/06 05:17:05]

I'm with Oleksandr here, would prefer it if FilterEngine cleaned up after
itself.

[Wladimir Palant, 2013/04/08 13:51:47]

Now that this map stores shared_ptr instances cleaning up happens automatically.

+  return *result;
+#endif
+}
+
+Subscription& FilterEngine::GetSubscription(const std::string& url)
+{
+#if FILTER_ENGINE_STUBS
+  std::map<std::string, Subscription*>::const_iterator it = knownSubscriptions.find(url);
+  if (it != knownSubscriptions.end())
+    return *it->second;
+
+  Subscription* result = new Subscription(*this, url);
+  knownSubscriptions[url] = result;
+  return *result;
+#endif
+}
+
+const std::vector<Filter*>& FilterEngine::GetListedFilters() const
+{
+#if FILTER_ENGINE_STUBS
+  return listedFilters;
+#endif
+}
+
+const std::vector<Subscription*>& FilterEngine::GetListedSubscriptions() const
+{
+#if FILTER_ENGINE_STUBS
+  return listedSubscriptions;
+#endif
+}
+
+void FilterEngine::FetchAvailableSubscriptions(SubscriptionsCallback callback)
+{
+#if FILTER_ENGINE_STUBS
+  std::vector<Subscription*> availableSubscriptions;
+
+  Subscription& subscription1 = GetSubscription("https://easylist-downloads.adblockplus.org/easylist.txt");
+  subscription1.SetProperty("title", "EasyList");
+  availableSubscriptions.push_back(&subscription1);
+
+  Subscription& subscription2 = GetSubscription("https://easylist-downloads.adblockplus.org/easylistgermany+easylist.txt");
+  subscription2.SetProperty("title", "EasyList Germany+EasyList");
+  availableSubscriptions.push_back(&subscription2);
+
+  callback(availableSubscriptions);
+#endif
+}
+
+Filter* FilterEngine::Matches(const std::string& url,
+                              const std::string& contentType,
+                              const std::string& documentUrl)
+{
+#if FILTER_ENGINE_STUBS
   //For test on http://simple-adblock.com/faq/testing-your-adblocker/
-  return url.find("adbanner.gif") != std::string::npos;
-}
-
-std::vector<std::string> FilterEngine::GetElementHidingRules() const
-{
-  std::vector<std::string> hidingRules;
-  hidingRules.push_back("###ad");
-  hidingRules.push_back("##.ad");
+  if (url.find("adbanner.gif") != std::string::npos)
+    return &GetFilter("adbanner.gif");
+  else if (url.find("notbanner.gif") != std::string::npos)
+    return &GetFilter("@@notbanner.gif");
+  else
+    return 0;
+#endif
+}
+
+std::vector<std::string> FilterEngine::GetElementHidingSelectors(const std::string& domain) const
+{
+#if FILTER_ENGINE_STUBS
+  std::vector<std::string> selectors;
+  selectors.push_back("#ad");
+  selectors.push_back(".ad");
   //For test on http://simple-adblock.com/faq/testing-your-adblocker/
-  hidingRules.push_back("##.ad_300x250");
-  return hidingRules;
-}
+  if (domain == "simple-adblock.com")
+    selectors.push_back(".ad_300x250");
+  return selectors;
+#endif
+}