capybara-webkit 0.13.2 → 0.14.0

data/src/Evaluate.h

@@ -8,13 +8,5 @@ class Evaluate : public SocketCommand {
   public:
     Evaluate(WebPageManager *, QStringList &arguments, QObject *parent = 0);
     virtual void start();
-
-  private:
-    void addVariant(QVariant &object);
-    void addString(QString &string);
-    void addArray(QVariantList &list);
-    void addMap(QVariantMap &map);
-
-    QString m_buffer;
 };
 

data/src/Execute.cpp

@@ -9,9 +9,9 @@ void Execute::start() {
   QString script = arguments()[0] + QString("; 'success'");
   QVariant result = page()->currentFrame()->evaluateJavaScript(script);
   if (result.isValid()) {
-    emit finished(new Response(true));
+    emitFinished(true);
   } else {
-    emit finished(new Response(false, QString("Javascript failed to execute")));
+    emitFinished(false, QString("Javascript failed to execute"));
   }
 }
 

data/src/Find.cpp

@@ -12,9 +12,9 @@ void Find::start() {
 
   if (result.isValid()) {
     message = result.toString();
-    emit finished(new Response(true, message));
+    emitFinished(true, message);
   } else {
-    emit finished(new Response(false, QString("Invalid XPath expression")));
+    emitFinished(false, QString("Invalid XPath expression"));
   }
 }
 

data/src/FrameFocus.cpp

@@ -51,7 +51,7 @@ void FrameFocus::focusId(QString name) {
 
 void FrameFocus::focusParent() {
   if (page()->currentFrame()->parentFrame() == 0) {
-    emit finished(new Response(false, QString("Already at parent frame.")));
+    emitFinished(false, QString("Already at parent frame."));
   } else {
     page()->currentFrame()->parentFrame()->setFocus();
     success();
@@ -59,9 +59,9 @@ void FrameFocus::focusParent() {
 }
 
 void FrameFocus::frameNotFound() {
-  emit finished(new Response(false, QString("Unable to locate frame. ")));
+  emitFinished(false, QString("Unable to locate frame. "));
 }
 
 void FrameFocus::success() {
-  emit finished(new Response(true));
+  emitFinished(true);
 }

data/src/GetCookies.cpp

@@ -15,5 +15,5 @@ void GetCookies::start()
     m_buffer.append(cookie.toRawForm());
     m_buffer.append("\n");
   }
-  emit finished(new Response(true, m_buffer));
+  emitFinished(true, m_buffer);
 }

data/src/GetTimeout.cpp

@@ -5,5 +5,5 @@ GetTimeout::GetTimeout(WebPageManager *manager, QStringList &arguments, QObject
 }
 
 void GetTimeout::start() {
-  emit finished(new Response(true, QString::number(manager()->getTimeout())));
+  emitFinished(true, QString::number(manager()->getTimeout()));
 }

data/src/GetWindowHandle.cpp

@@ -7,5 +7,5 @@ GetWindowHandle::GetWindowHandle(WebPageManager *manager, QStringList &arguments
 }
 
 void GetWindowHandle::start() {
-  emit finished(new Response(true, page()->uuid()));
+  emitFinished(true, page()->uuid());
 }

data/src/GetWindowHandles.cpp

@@ -2,19 +2,20 @@
 #include "WebPageManager.h"
 #include "CommandFactory.h"
 #include "WebPage.h"
+#include "JsonSerializer.h"
 #include <QStringList>
 
 GetWindowHandles::GetWindowHandles(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {
 }
 
 void GetWindowHandles::start() {
-  QString handles = "[";
-  QStringList stringList;
+  QVariantList handles;
 
   foreach(WebPage *page, manager()->pages())
-    stringList.append("\"" + page->uuid() + "\"");
+    handles << page->uuid();
 
-  handles += stringList.join(",") + "]";
+  JsonSerializer serializer;
+  QByteArray json = serializer.serialize(handles);
 
-  emit finished(new Response(true, handles));
+  emitFinished(true, json);
 }

data/src/Header.cpp

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

data/src/Headers.cpp

@@ -11,6 +11,6 @@ void Headers::start() {
   foreach(QNetworkReply::RawHeaderPair header, page()->pageHeaders())
     headers << header.first+": "+header.second;
 
-  emit finished(new Response(true, headers.join("\n")));
+  emitFinished(true, headers.join("\n"));
 }
 

data/src/IgnoreSslErrors.cpp

@@ -8,6 +8,6 @@ IgnoreSslErrors::IgnoreSslErrors(WebPageManager *manager, QStringList &arguments
 
 void IgnoreSslErrors::start() {
   manager()->setIgnoreSslErrors(true);
-  emit finished(new Response(true));
+  emitFinished(true);
 }
 

data/src/JavascriptAlertMessages.cpp

@@ -1,10 +1,13 @@
 #include "JavascriptAlertMessages.h"
 #include "WebPage.h"
 #include "WebPageManager.h"
+#include "JsonSerializer.h"
 
 JavascriptAlertMessages::JavascriptAlertMessages(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {}
 
 void JavascriptAlertMessages::start()
 {
-  emit finished(new Response(true, page()->alertMessages()));
+  JsonSerializer serializer;
+  QByteArray json = serializer.serialize(page()->alertMessages());
+  emitFinished(true, json);
 }

data/src/JavascriptConfirmMessages.cpp

@@ -1,10 +1,13 @@
 #include "JavascriptConfirmMessages.h"
 #include "WebPage.h"
 #include "WebPageManager.h"
+#include "JsonSerializer.h"
 
 JavascriptConfirmMessages::JavascriptConfirmMessages(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {}
 
 void JavascriptConfirmMessages::start()
 {
-  emit finished(new Response(true, page()->confirmMessages()));
+  JsonSerializer serializer;
+  QByteArray json = serializer.serialize(page()->confirmMessages());
+  emitFinished(true, json);
 }

data/src/JavascriptPromptMessages.cpp

@@ -1,10 +1,13 @@
 #include "JavascriptPromptMessages.h"
 #include "WebPage.h"
 #include "WebPageManager.h"
+#include "JsonSerializer.h"
 
 JavascriptPromptMessages::JavascriptPromptMessages(WebPageManager *manager, QStringList &arguments, QObject *parent) : SocketCommand(manager, arguments, parent) {}
 
 void JavascriptPromptMessages::start()
 {
-  emit finished(new Response(true, page()->promptMessages()));
+  JsonSerializer serializer;
+  QByteArray json = serializer.serialize(page()->promptMessages());
+  emitFinished(true, json);
 }

data/src/JsonSerializer.cpp

@@ -0,0 +1,116 @@
+#include "JsonSerializer.h"
+#include <cmath>
+
+JsonSerializer::JsonSerializer(QObject *parent) : QObject(parent) {
+}
+
+QByteArray JsonSerializer::serialize(const QVariant &object) {
+  addVariant(object);
+  return m_buffer;
+}
+
+void JsonSerializer::addVariant(const QVariant &object) {
+  if (object.isValid()) {
+    switch(object.type()) {
+      case QMetaType::QString:
+        {
+          QString string = object.toString();
+          addString(string);
+        }
+        break;
+      case QMetaType::QVariantList:
+        {
+          QVariantList list = object.toList();
+          addArray(list);
+        }
+        break;
+      case QMetaType::Double:
+        if (std::isinf(object.toDouble()))
+          m_buffer.append("null");
+        else
+          m_buffer.append(object.toString());
+        break;
+      case QMetaType::QVariantMap:
+        {
+          QVariantMap map = object.toMap();
+          addMap(map);
+          break;
+        }
+      case QMetaType::Bool:
+        {
+          m_buffer.append(object.toString());
+          break;
+        }
+      case QMetaType::Int:
+        {
+          m_buffer.append(object.toString());
+          break;
+        }
+      default:
+        m_buffer.append("null");
+    }
+  } else {
+    m_buffer.append("null");
+  }
+}
+
+void JsonSerializer::addString(const QString &string) {
+  m_buffer.append("\"");
+  m_buffer.append(sanitizeString(string));
+  m_buffer.append("\"");
+}
+
+void JsonSerializer::addArray(const QVariantList &list) {
+  m_buffer.append("[");
+  for (int i = 0; i < list.length(); i++) {
+    if (i > 0)
+      m_buffer.append(",");
+    addVariant(list[i]);
+  }
+  m_buffer.append("]");
+}
+
+void JsonSerializer::addMap(const QVariantMap &map) {
+  m_buffer.append("{");
+  QMapIterator<QString, QVariant> iterator(map);
+  while (iterator.hasNext()) {
+    iterator.next();
+    QString key = iterator.key();
+    QVariant value = iterator.value();
+    addString(key);
+    m_buffer.append(":");
+    addVariant(value);
+    if (iterator.hasNext())
+      m_buffer.append(",");
+  }
+  m_buffer.append("}");
+}
+
+QByteArray JsonSerializer::sanitizeString(QString str) {
+  str.replace("\\", "\\\\");
+  str.replace("\"", "\\\"");
+  str.replace("\b", "\\b");
+  str.replace("\f", "\\f");
+  str.replace("\n", "\\n");
+  str.replace("\r", "\\r");
+  str.replace("\t", "\\t");
+
+  QByteArray result;
+  const ushort* unicode = str.utf16();
+  unsigned int i = 0;
+
+  while (unicode[i]) {
+    if (unicode[i] > 31 && unicode[i] < 128) {
+      result.append(unicode[i]);
+    }
+    else {
+      QString hexCode = QString::number(unicode[i], 16).rightJustified(4, '0');
+
+      result.append("\\u").append(hexCode);
+    }
+    ++i;
+  }
+
+  return result;
+}
+

data/src/JsonSerializer.h

@@ -0,0 +1,20 @@
+#include <QObject>
+#include <QVariantList>
+
+class JsonSerializer : public QObject {
+  Q_OBJECT
+
+  public:
+    JsonSerializer(QObject *parent = 0);
+    QByteArray serialize(const QVariant &object);
+
+  private:
+    void addVariant(const QVariant &object);
+    void addString(const QString &string);
+    void addArray(const QVariantList &list);
+    void addMap(const QVariantMap &map);
+    QByteArray sanitizeString(QString string);
+
+    QByteArray m_buffer;
+};
+

data/src/NetworkAccessManager.cpp

@@ -2,6 +2,7 @@
 #include "WebPage.h"
 #include <iostream>
 #include <fstream>
+#include "NoOpReply.h"
 
 NetworkAccessManager::NetworkAccessManager(QObject *parent):QNetworkAccessManager(parent) {
   connect(this, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)), SLOT(provideAuthentication(QNetworkReply*,QAuthenticator*)));
@@ -11,24 +12,36 @@ NetworkAccessManager::NetworkAccessManager(QObject *parent):QNetworkAccessManage
 QNetworkReply* NetworkAccessManager::createRequest(QNetworkAccessManager::Operation operation, const QNetworkRequest &request, QIODevice * outgoingData = 0) {
   QNetworkRequest new_request(request);
   QByteArray url = new_request.url().toEncoded();
-  if (operation != QNetworkAccessManager::PostOperation && operation != QNetworkAccessManager::PutOperation) {
-    new_request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant());
+  if (this->isBlacklisted(new_request.url())) {
+    return 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().toAscii(), item.value().toAscii());
+    }
+    QNetworkReply *reply = QNetworkAccessManager::createRequest(operation, new_request, outgoingData);
+    emit requestCreated(url, reply);
+    return reply;
   }
-  QHashIterator<QString, QString> item(m_headers);
-  while (item.hasNext()) {
-      item.next();
-      new_request.setRawHeader(item.key().toAscii(), item.value().toAscii());
-  }
-  QNetworkReply *reply = QNetworkAccessManager::createRequest(operation, new_request, outgoingData);
-  emit requestCreated(url, reply);
-  return reply;
-}
+};
 
 void NetworkAccessManager::finished(QNetworkReply *reply) {
-  NetworkResponse response;
-  response.statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-  response.headers = reply->rawHeaderPairs();
-  m_responses[reply->url()] = response;
+  QUrl redirectUrl = reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
+  if (redirectUrl.isValid())
+    m_redirectMappings[reply->url().resolved(redirectUrl)] = reply->url();
+  else {
+    QUrl requestedUrl = reply->url();
+    while (m_redirectMappings.contains(requestedUrl))
+      requestedUrl = m_redirectMappings.take(requestedUrl);
+    NetworkResponse response;
+    response.statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    response.headers = reply->rawHeaderPairs();
+    m_responses[requestedUrl] = response;
+  }
 }
 
 void NetworkAccessManager::addHeader(QString key, QString value) {
@@ -49,8 +62,10 @@ void NetworkAccessManager::setPassword(const QString &password) {
 
 void NetworkAccessManager::provideAuthentication(QNetworkReply *reply, QAuthenticator *authenticator) {
   Q_UNUSED(reply);
-  authenticator->setUser(m_userName);
-  authenticator->setPassword(m_password);
+  if (m_userName != authenticator->user()) 
+    authenticator->setUser(m_userName);
+  if (m_password != authenticator->password())
+    authenticator->setPassword(m_password);
 }
 
 int NetworkAccessManager::statusFor(QUrl url) {
@@ -60,3 +75,29 @@ int NetworkAccessManager::statusFor(QUrl url) {
 const QList<QNetworkReply::RawHeaderPair> &NetworkAccessManager::headersFor(QUrl url) {
   return m_responses[url].headers;
 }
+
+void NetworkAccessManager::setUrlBlacklist(QStringList urlBlacklist) {
+  m_urlBlacklist.clear();
+
+  QStringListIterator iter(urlBlacklist);
+  while (iter.hasNext()) {
+    m_urlBlacklist << QUrl(iter.next());
+  }
+};
+
+bool NetworkAccessManager::isBlacklisted(QUrl url) {
+  QListIterator<QUrl> iter(m_urlBlacklist);
+
+  while (iter.hasNext()) {
+    QUrl blacklisted = iter.next();
+
+    if (blacklisted == url) {
+      return true;
+    } else if (blacklisted.path().isEmpty() && blacklisted.isParentOf(url)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+

data/src/NetworkAccessManager.h

@@ -1,6 +1,7 @@
 #include <QtNetwork/QNetworkAccessManager>
 #include <QtNetwork/QNetworkRequest>
 #include <QtNetwork/QNetworkReply>
+#include <QStringList>
 
 class NetworkAccessManager : public QNetworkAccessManager {
 
@@ -20,15 +21,20 @@ class NetworkAccessManager : public QNetworkAccessManager {
     void setPassword(const QString &password);
     int statusFor(QUrl url);
     const QList<QNetworkReply::RawHeaderPair> &headersFor(QUrl url);
+    void setUrlBlacklist(QStringList urlBlacklist);
 
   protected:
     QNetworkReply* createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest &req, QIODevice * outgoingData);
     QString m_userName;
     QString m_password;
+    QList<QUrl> m_urlBlacklist;
+
 
   private:
     QHash<QString, QString> m_headers;
     QHash<QUrl, NetworkResponse> m_responses;
+    bool isBlacklisted(QUrl url);
+    QHash<QUrl, QUrl> m_redirectMappings;
 
   private slots:
     void provideAuthentication(QNetworkReply *reply, QAuthenticator *authenticator);