capybara-webkit 1.3.1 → 1.4.0

data/src/AllowUrl.h

@@ -0,0 +1,10 @@
+#include "SocketCommand.h"
+
+class AllowUrl : public SocketCommand {
+  Q_OBJECT
+
+  public:
+    AllowUrl(WebPageManager *, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+};
+

data/src/BlacklistedRequestHandler.cpp

@@ -0,0 +1,56 @@
+#include "BlacklistedRequestHandler.h"
+#include "NetworkReplyProxy.h"
+#include "NoOpReply.h"
+
+BlacklistedRequestHandler::BlacklistedRequestHandler(
+  RequestHandler *next,
+  QObject *parent
+) : RequestHandler(parent) {
+  m_next = next;
+}
+
+QNetworkReply* BlacklistedRequestHandler::handleRequest(
+  NetworkAccessManager *manager,
+  QNetworkAccessManager::Operation operation,
+  QNetworkRequest &request,
+  QIODevice *outgoingData
+) {
+  if (this->isBlacklisted(request.url())) {
+    return new NetworkReplyProxy(new NoOpReply(request), this);
+  } else {
+    return m_next->handleRequest(manager, operation, request, outgoingData);
+  }
+}
+
+void BlacklistedRequestHandler::setUrlBlacklist(QStringList urlBlacklist) {
+  m_urlBlacklist.clear();
+
+  QStringListIterator iter(urlBlacklist);
+  while (iter.hasNext()) {
+    m_urlBlacklist << iter.next();
+  }
+}
+
+bool BlacklistedRequestHandler::isBlacklisted(QUrl url) {
+  QString urlString = url.toString();
+  QStringListIterator iter(m_urlBlacklist);
+
+  while (iter.hasNext()) {
+    QRegExp blacklisted = QRegExp(iter.next());
+    blacklisted.setPatternSyntax(QRegExp::Wildcard);
+
+    if(urlString.contains(blacklisted)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void BlacklistedRequestHandler::blockUrl(const QString &url) {
+  m_urlBlacklist.append(url);
+}
+
+void BlacklistedRequestHandler::reset() {
+  m_urlBlacklist.clear();
+}

data/src/BlacklistedRequestHandler.h

@@ -0,0 +1,22 @@
+#include <QStringList>
+
+#include "RequestHandler.h"
+
+class BlacklistedRequestHandler : public RequestHandler {
+  public:
+    BlacklistedRequestHandler(RequestHandler *next, QObject *parent = 0);
+    virtual QNetworkReply* handleRequest(
+      NetworkAccessManager *,
+      QNetworkAccessManager::Operation,
+      QNetworkRequest &,
+      QIODevice *
+    );
+    void setUrlBlacklist(QStringList urlBlacklist);
+    void blockUrl(const QString &);
+    void reset();
+
+  private:
+    RequestHandler *m_next;
+    QStringList m_urlBlacklist;
+    bool isBlacklisted(QUrl url);
+};

data/src/BlockUrl.cpp

@@ -0,0 +1,16 @@
+#include "BlockUrl.h"
+#include "SocketCommand.h"
+#include "WebPage.h"
+#include "WebPageManager.h"
+
+BlockUrl::BlockUrl(
+  WebPageManager *manager,
+  QStringList &arguments,
+  QObject *parent
+) : SocketCommand(manager, arguments, parent) {
+}
+
+void BlockUrl::start() {
+  manager()->blockUrl(arguments()[0]);
+  finish(true);
+}

data/src/BlockUrl.h

@@ -0,0 +1,10 @@
+#include "SocketCommand.h"
+
+class BlockUrl : public SocketCommand {
+  Q_OBJECT
+
+  public:
+    BlockUrl(WebPageManager *, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+};
+

data/src/CommandFactory.cpp

@@ -48,6 +48,9 @@
 #include "GoForward.h"
 #include "AcceptAlert.h"
 #include "FindModal.h"
+#include "SetUnknownUrlMode.h"
+#include "AllowUrl.h"
+#include "BlockUrl.h"
 
 CommandFactory::CommandFactory(WebPageManager *manager, QObject *parent) : QObject(parent) {
   m_manager = manager;

data/src/CustomHeadersRequestHandler.cpp

@@ -0,0 +1,37 @@
+#include "CustomHeadersRequestHandler.h"
+#include "NetworkReplyProxy.h"
+#include "NoOpReply.h"
+
+CustomHeadersRequestHandler::CustomHeadersRequestHandler(
+  RequestHandler *next,
+  QObject *parent
+) : RequestHandler(parent) {
+  m_next = next;
+}
+
+QNetworkReply* CustomHeadersRequestHandler::handleRequest(
+  NetworkAccessManager *manager,
+  QNetworkAccessManager::Operation operation,
+  QNetworkRequest &request,
+  QIODevice *outgoingData
+) {
+  Q_UNUSED(manager)
+  Q_UNUSED(operation)
+  Q_UNUSED(outgoingData)
+
+  QHashIterator<QString, QString> item(m_headers);
+  while (item.hasNext()) {
+    item.next();
+    request.setRawHeader(item.key().toLatin1(), item.value().toLatin1());
+  }
+
+  return m_next->handleRequest(manager, operation, request, outgoingData);
+}
+
+void CustomHeadersRequestHandler::addHeader(QString key, QString value) {
+  m_headers.insert(key, value);
+}
+
+void CustomHeadersRequestHandler::reset() {
+  m_headers.clear();
+}

data/src/CustomHeadersRequestHandler.h

@@ -0,0 +1,21 @@
+#include <QHash>
+#include <QString>
+
+#include "RequestHandler.h"
+
+class CustomHeadersRequestHandler : public RequestHandler {
+  public:
+    CustomHeadersRequestHandler(RequestHandler *next, QObject *parent = 0);
+    virtual QNetworkReply* handleRequest(
+      NetworkAccessManager *,
+      QNetworkAccessManager::Operation,
+      QNetworkRequest &,
+      QIODevice *
+    );
+    void addHeader(QString, QString);
+    virtual void reset();
+
+  private:
+    RequestHandler *m_next;
+    QHash<QString, QString> m_headers;
+};

data/src/Header.cpp

@@ -9,11 +9,10 @@ Header::Header(WebPageManager *manager, QStringList &arguments, QObject *parent)
 void Header::start() {
   QString key = arguments()[0];
   QString value = arguments()[1];
-  NetworkAccessManager* networkAccessManager = manager()->networkAccessManager();
   if (key.toLower().replace("-", "_") == "user_agent") {
     page()->setUserAgent(value);
   } else {
-    networkAccessManager->addHeader(key, value);
+    manager()->addHeader(key, value);
   }
   finish(true);
 }

data/src/MissingContentHeaderRequestHandler.cpp

@@ -0,0 +1,23 @@
+#include "MissingContentHeaderRequestHandler.h"
+#include "NetworkReplyProxy.h"
+#include "NoOpReply.h"
+
+MissingContentHeaderRequestHandler::MissingContentHeaderRequestHandler(
+  RequestHandler *next,
+  QObject *parent
+) : RequestHandler(parent) {
+  m_next = next;
+}
+
+QNetworkReply* MissingContentHeaderRequestHandler::handleRequest(
+  NetworkAccessManager *manager,
+  QNetworkAccessManager::Operation operation,
+  QNetworkRequest &request,
+  QIODevice *outgoingData
+) {
+  if (operation != QNetworkAccessManager::PostOperation && operation != QNetworkAccessManager::PutOperation) {
+    request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant());
+  }
+
+  return m_next->handleRequest(manager, operation, request, outgoingData);
+}

data/src/MissingContentHeaderRequestHandler.h

@@ -0,0 +1,15 @@
+#include "RequestHandler.h"
+
+class MissingContentHeaderRequestHandler : public RequestHandler {
+  public:
+    MissingContentHeaderRequestHandler(RequestHandler *next, QObject *parent = 0);
+    virtual QNetworkReply* handleRequest(
+      NetworkAccessManager *,
+      QNetworkAccessManager::Operation,
+      QNetworkRequest &,
+      QIODevice *
+    );
+
+  private:
+    RequestHandler *m_next;
+};

data/src/NetworkAccessManager.cpp

@@ -1,34 +1,46 @@
 #include "NetworkAccessManager.h"
 #include "WebPage.h"
-#include <iostream>
-#include <fstream>
-#include "NoOpReply.h"
 #include "NetworkReplyProxy.h"
+#include "RequestHandler.h"
 
-NetworkAccessManager::NetworkAccessManager(QObject *parent):QNetworkAccessManager(parent) {
+NetworkAccessManager::NetworkAccessManager(
+  RequestHandler * requestHandler,
+  QObject *parent
+) : QNetworkAccessManager(parent) {
+  m_requestHandler = requestHandler;
   connect(this, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)), SLOT(provideAuthentication(QNetworkReply*,QAuthenticator*)));
   connect(this, SIGNAL(finished(QNetworkReply *)), this, SLOT(finished(QNetworkReply *)));
   disableKeyChainLookup();
 }
 
-QNetworkReply* NetworkAccessManager::createRequest(QNetworkAccessManager::Operation operation, const QNetworkRequest &request, QIODevice * outgoingData = 0) {
-  QNetworkRequest new_request(request);
-  QByteArray url = new_request.url().toEncoded();
-  if (this->isBlacklisted(new_request.url())) {
-    return new NetworkReplyProxy(new NoOpReply(new_request), this);
-  } else {
-    if (operation != QNetworkAccessManager::PostOperation && operation != QNetworkAccessManager::PutOperation) {
-      new_request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant());
-    }
-    QHashIterator<QString, QString> item(m_headers);
-    while (item.hasNext()) {
-        item.next();
-        new_request.setRawHeader(item.key().toLatin1(), item.value().toLatin1());
-    }
-    QNetworkReply *reply = new NetworkReplyProxy(QNetworkAccessManager::createRequest(operation, new_request, outgoingData), this);
-    emit requestCreated(url, reply);
-    return reply;
-  }
+QNetworkReply* NetworkAccessManager::sendRequest(
+  QNetworkAccessManager::Operation operation,
+  const QNetworkRequest &request,
+  QIODevice * outgoingData
+) {
+  QNetworkReply *reply = new NetworkReplyProxy(
+    QNetworkAccessManager::createRequest(operation,
+      request,
+      outgoingData
+    ),
+    this
+  );
+
+  QByteArray url = reply->request().url().toEncoded();
+  emit requestCreated(url, reply);
+
+  return reply;
+}
+
+QNetworkReply* NetworkAccessManager::createRequest(
+  QNetworkAccessManager::Operation operation,
+  const QNetworkRequest &unsafeRequest,
+  QIODevice * outgoingData = 0
+) {
+  QNetworkRequest request(unsafeRequest);
+  QNetworkReply *reply =
+    m_requestHandler->handleRequest(this, operation, request, outgoingData);
+  return reply;
 };
 
 void NetworkAccessManager::finished(QNetworkReply *reply) {
@@ -43,12 +55,7 @@ void NetworkAccessManager::finished(QNetworkReply *reply) {
   }
 }
 
-void NetworkAccessManager::addHeader(QString key, QString value) {
-  m_headers.insert(key, value);
-}
-
 void NetworkAccessManager::reset() {
-  m_headers.clear();
   m_userName = QString();
   m_password = QString();
 }
@@ -63,37 +70,12 @@ void NetworkAccessManager::setPassword(const QString &password) {
 
 void NetworkAccessManager::provideAuthentication(QNetworkReply *reply, QAuthenticator *authenticator) {
   Q_UNUSED(reply);
-  if (m_userName != authenticator->user()) 
+  if (m_userName != authenticator->user())
     authenticator->setUser(m_userName);
   if (m_password != authenticator->password())
     authenticator->setPassword(m_password);
 }
 
-void NetworkAccessManager::setUrlBlacklist(QStringList urlBlacklist) {
-  m_urlBlacklist.clear();
-
-  QStringListIterator iter(urlBlacklist);
-  while (iter.hasNext()) {
-    m_urlBlacklist << iter.next();
-  }
-};
-
-bool NetworkAccessManager::isBlacklisted(QUrl url) {
-  QString urlString = url.toString();
-  QStringListIterator iter(m_urlBlacklist);
-
-  while (iter.hasNext()) {
-    QRegExp blacklisted = QRegExp(iter.next());
-    blacklisted.setPatternSyntax(QRegExp::Wildcard);
-
-    if(urlString.contains(blacklisted)) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
 /*
  * This is a workaround for a Qt 5/OS X bug:
  * https://bugreports.qt-project.org/browse/QTBUG-30434

data/src/NetworkAccessManager.h

@@ -3,32 +3,37 @@
 #include <QtNetwork/QNetworkAccessManager>
 #include <QtNetwork/QNetworkRequest>
 #include <QtNetwork/QNetworkReply>
-#include <QStringList>
 
-class NetworkAccessManager : public QNetworkAccessManager {
+class RequestHandler;
 
+class NetworkAccessManager : public QNetworkAccessManager {
   Q_OBJECT
 
   public:
-    NetworkAccessManager(QObject *parent = 0);
-    void addHeader(QString key, QString value);
+    NetworkAccessManager(RequestHandler *, QObject *parent = 0);
     void reset();
     void setUserName(const QString &userName);
     void setPassword(const QString &password);
-    void setUrlBlacklist(QStringList urlBlacklist);
+    QNetworkReply* sendRequest(
+      QNetworkAccessManager::Operation,
+      const QNetworkRequest &,
+      QIODevice *
+    );
 
   protected:
-    QNetworkReply* createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest &req, QIODevice * outgoingData);
+    QNetworkReply* createRequest(
+      QNetworkAccessManager::Operation,
+      const QNetworkRequest &,
+      QIODevice *
+    );
     QString m_userName;
     QString m_password;
-    QStringList m_urlBlacklist;
 
   private:
     void disableKeyChainLookup();
 
-    QHash<QString, QString> m_headers;
-    bool isBlacklisted(QUrl url);
     QHash<QUrl, QUrl> m_redirectMappings;
+    RequestHandler * m_requestHandler;
 
   private slots:
     void provideAuthentication(QNetworkReply *reply, QAuthenticator *authenticator);

data/src/NetworkRequestFactory.cpp

@@ -0,0 +1,15 @@
+#include "NetworkRequestFactory.h"
+#include "NetworkAccessManager.h"
+
+NetworkRequestFactory::NetworkRequestFactory(QObject *parent) :
+  RequestHandler(parent) {
+}
+
+QNetworkReply* NetworkRequestFactory::handleRequest(
+  NetworkAccessManager *manager,
+  QNetworkAccessManager::Operation operation,
+  QNetworkRequest &request,
+  QIODevice *outgoingData
+) {
+  return manager->sendRequest(operation, request, outgoingData);
+}

data/src/NetworkRequestFactory.h

@@ -0,0 +1,12 @@
+#include "RequestHandler.h"
+
+class NetworkRequestFactory : public RequestHandler {
+  public:
+    NetworkRequestFactory(QObject *parent = 0);
+    virtual QNetworkReply* handleRequest(
+      NetworkAccessManager *,
+      QNetworkAccessManager::Operation,
+      QNetworkRequest &,
+      QIODevice *
+    );
+};