otherinbox-capybara-webkit 0.12.0

data/src/FrameFocus.h

@@ -0,0 +1,28 @@
+#include "Command.h"
+
+class WebPage;
+class QWebFrame;
+
+class FrameFocus : public Command {
+  Q_OBJECT
+
+  public:
+    FrameFocus(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+
+  private:
+    void findFrames();
+
+    void focusParent();
+
+    void focusIndex(int index);
+    bool isFrameAtIndex(int index);
+
+    void focusId(QString id);
+
+    void success();
+    void frameNotFound();
+
+    QList<QWebFrame *> frames;
+};
+

data/src/GetCookies.cpp

@@ -0,0 +1,20 @@
+#include "GetCookies.h"
+#include "WebPage.h"
+#include "NetworkCookieJar.h"
+
+GetCookies::GetCookies(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent)
+{
+  m_buffer = "";
+}
+
+void GetCookies::start()
+{
+  NetworkCookieJar *jar = qobject_cast<NetworkCookieJar*>(page()
+                                                          ->networkAccessManager()
+                                                          ->cookieJar());
+  foreach (QNetworkCookie cookie, jar->getAllCookies()) {
+    m_buffer.append(cookie.toRawForm());
+    m_buffer.append("\n");
+  }
+  emit finished(new Response(true, m_buffer));
+}

data/src/GetCookies.h

@@ -0,0 +1,14 @@
+#include "Command.h"
+
+class WebPage;
+
+class GetCookies : public Command {
+  Q_OBJECT;
+
+ public:
+  GetCookies(WebPage *page, QStringList &arguments, QObject *parent = 0);
+  virtual void start();
+
+ private:
+  QString m_buffer;
+};

data/src/Header.cpp

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

data/src/Header.h

@@ -0,0 +1,11 @@
+#include "Command.h"
+
+class WebPage;
+
+class Header : public Command {
+  Q_OBJECT
+
+  public:
+    Header(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+};

data/src/Headers.cpp

@@ -0,0 +1,10 @@
+#include "Headers.h"
+#include "WebPage.h"
+
+Headers::Headers(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Headers::start() {
+  emit finished(new Response(true, page()->pageHeaders()));
+}
+

data/src/Headers.h

@@ -0,0 +1,12 @@
+#include "Command.h"
+
+class WebPage;
+
+class Headers : public Command {
+  Q_OBJECT
+
+  public:
+    Headers(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+};
+

data/src/IgnoreSslErrors.cpp

@@ -0,0 +1,12 @@
+#include "IgnoreSslErrors.h"
+#include "WebPage.h"
+
+IgnoreSslErrors::IgnoreSslErrors(WebPage *page, QStringList &arguments, QObject *parent) :
+  Command(page, arguments, parent) {
+}
+
+void IgnoreSslErrors::start() {
+  page()->ignoreSslErrors();
+  emit finished(new Response(true));
+}
+

data/src/IgnoreSslErrors.h

@@ -0,0 +1,12 @@
+#include "Command.h"
+
+class WebPage;
+
+class IgnoreSslErrors : public Command {
+  Q_OBJECT
+
+  public:
+    IgnoreSslErrors(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+};
+

data/src/JavascriptInvocation.cpp

@@ -0,0 +1,14 @@
+#include "JavascriptInvocation.h"
+
+JavascriptInvocation::JavascriptInvocation(QString &functionName, QStringList &arguments, QObject *parent) : QObject(parent) {
+  m_functionName = functionName;
+  m_arguments = arguments;
+}
+
+QString &JavascriptInvocation::functionName() {
+  return m_functionName;
+}
+
+QStringList &JavascriptInvocation::arguments() {
+  return m_arguments;
+}

data/src/JavascriptInvocation.h

@@ -0,0 +1,19 @@
+#include <QObject>
+#include <QString>
+#include <QStringList>
+
+class JavascriptInvocation : public QObject {
+  Q_OBJECT
+  Q_PROPERTY(QString functionName READ functionName)
+  Q_PROPERTY(QStringList arguments READ arguments)
+
+  public:
+    JavascriptInvocation(QString &functionName, QStringList &arguments, QObject *parent = 0);
+    QString &functionName();
+    QStringList &arguments();
+
+  private:
+    QString m_functionName;
+    QStringList m_arguments;
+};
+

data/src/NetworkAccessManager.cpp

@@ -0,0 +1,29 @@
+#include "NetworkAccessManager.h"
+#include "WebPage.h"
+#include <iostream>
+
+
+NetworkAccessManager::NetworkAccessManager(QObject *parent):QNetworkAccessManager(parent) {
+}
+
+QNetworkReply* NetworkAccessManager::createRequest(QNetworkAccessManager::Operation operation, const QNetworkRequest &request, QIODevice * outgoingData = 0) {
+  QNetworkRequest new_request(request);
+  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());
+  }
+  return QNetworkAccessManager::createRequest(operation, new_request, outgoingData);
+};
+
+void NetworkAccessManager::addHeader(QString key, QString value) {
+  m_headers.insert(key, value);
+};
+
+void NetworkAccessManager::resetHeaders() {
+  m_headers.clear();
+};
+

data/src/NetworkAccessManager.h

@@ -0,0 +1,19 @@
+#include <QtNetwork/QNetworkAccessManager>
+#include <QtNetwork/QNetworkRequest>
+#include <QtNetwork/QNetworkReply>
+
+class NetworkAccessManager : public QNetworkAccessManager {
+
+  Q_OBJECT
+
+  public:
+    NetworkAccessManager(QObject *parent = 0);
+    void addHeader(QString key, QString value);
+    void resetHeaders();
+
+  protected:
+    QNetworkReply* createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest &req, QIODevice * outgoingData);
+
+  private:
+    QHash<QString, QString> m_headers;
+};

data/src/NetworkCookieJar.cpp

@@ -0,0 +1,101 @@
+#include "NetworkCookieJar.h"
+#include "QtCore/qdatetime.h"
+
+NetworkCookieJar::NetworkCookieJar(QObject *parent)
+  : QNetworkCookieJar(parent)
+{ }
+
+QList<QNetworkCookie> NetworkCookieJar::getAllCookies() const
+{
+  return allCookies();
+}
+
+void NetworkCookieJar::clearCookies()
+{
+  setAllCookies(QList<QNetworkCookie>());
+}
+
+static inline bool isParentDomain(QString domain, QString reference)
+{
+  if (!reference.startsWith(QLatin1Char('.')))
+    return domain == reference;
+
+  return domain.endsWith(reference) || domain == reference.mid(1);
+}
+
+void NetworkCookieJar::overwriteCookies(const QList<QNetworkCookie>& cookieList)
+{
+  /* this function is basically a copy-and-paste of the original
+     QNetworkCookieJar::setCookiesFromUrl with the domain and
+     path validations removed */
+
+  QString defaultPath(QLatin1Char('/'));
+  QDateTime now = QDateTime::currentDateTime();
+  QList<QNetworkCookie> newCookies = allCookies();
+
+  foreach (QNetworkCookie cookie, cookieList) {
+    bool isDeletion = (!cookie.isSessionCookie() &&
+                       cookie.expirationDate() < now);
+
+    // validate the cookie & set the defaults if unset
+    if (cookie.path().isEmpty())
+      cookie.setPath(defaultPath);
+
+    // don't do path checking. See http://bugreports.qt.nokia.com/browse/QTBUG-5815
+    //        else if (!isParentPath(pathAndFileName, cookie.path())) {
+    //            continue;           // not accepted
+    //        }
+
+    if (cookie.domain().isEmpty()) {
+      continue;
+    } else {
+      // Ensure the domain starts with a dot if its field was not empty
+      // in the HTTP header. There are some servers that forget the
+      // leading dot and this is actually forbidden according to RFC 2109,
+      // but all browsers accept it anyway so we do that as well.
+      if (!cookie.domain().startsWith(QLatin1Char('.')))
+        cookie.setDomain(QLatin1Char('.') + cookie.domain());
+
+      QString domain = cookie.domain();
+
+      // the check for effective TLDs makes the "embedded dot" rule from RFC 2109 section 4.3.2
+      // redundant; the "leading dot" rule has been relaxed anyway, see above
+      // we remove the leading dot for this check
+      /*
+      if (QNetworkCookieJarPrivate::isEffectiveTLD(domain.remove(0, 1)))
+        continue; // not accepted
+      */
+    }
+
+    for (int i = 0; i < newCookies.size(); ++i) {
+      // does this cookie already exist?
+      const QNetworkCookie &current = newCookies.at(i);
+      if (cookie.name() == current.name() &&
+          cookie.domain() == current.domain() &&
+          cookie.path() == current.path()) {
+        // found a match
+        newCookies.removeAt(i);
+        break;
+      }
+    }
+
+    // did not find a match
+    if (!isDeletion) {
+      int countForDomain = 0;
+      for (int i = newCookies.size() - 1; i >= 0; --i) {
+        // Start from the end and delete the oldest cookies to keep a maximum count of 50.
+        const QNetworkCookie &current = newCookies.at(i);
+        if (isParentDomain(cookie.domain(), current.domain())
+            || isParentDomain(current.domain(), cookie.domain())) {
+          if (countForDomain >= 49)
+            newCookies.removeAt(i);
+          else
+            ++countForDomain;
+        }
+      }
+
+      newCookies += cookie;
+    }
+  }
+  setAllCookies(newCookies);
+}

data/src/NetworkCookieJar.h

@@ -0,0 +1,15 @@
+#include <QtNetwork/QNetworkCookieJar>
+#include <QtNetwork/QNetworkCookie>
+
+class NetworkCookieJar : public QNetworkCookieJar {
+
+  Q_OBJECT;
+
+ public:
+
+  NetworkCookieJar(QObject *parent = 0);
+
+  QList<QNetworkCookie> getAllCookies() const;
+  void clearCookies();
+  void overwriteCookies(const QList<QNetworkCookie>& cookieList);
+};

data/src/Node.cpp

@@ -0,0 +1,14 @@
+#include "Node.h"
+#include "WebPage.h"
+
+Node::Node(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Node::start() {
+  QStringList functionArguments(arguments());
+  QString functionName = functionArguments.takeFirst();
+  QVariant result = page()->invokeCapybaraFunction(functionName, functionArguments);
+  QString attributeValue = result.toString();
+  emit finished(new Response(true, attributeValue));
+}
+

data/src/Node.h

@@ -0,0 +1,13 @@
+#include "Command.h"
+#include <QStringList>
+
+class WebPage;
+
+class Node : public Command {
+  Q_OBJECT
+
+  public:
+    Node(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+};
+

data/src/NullCommand.cpp

@@ -0,0 +1,10 @@
+#include "NullCommand.h"
+#include "WebPage.h"
+
+NullCommand::NullCommand(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {}
+
+void NullCommand::start() {
+  QString failure = QString("[Capybara WebKit] Unknown command: ") + arguments()[0] + "\n";
+  emit finished(new Response(false, failure));
+}
+

data/src/NullCommand.h

@@ -0,0 +1,11 @@
+#include "Command.h"
+
+class WebPage;
+
+class NullCommand : public Command {
+  Q_OBJECT
+
+  public:
+    NullCommand(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+};

data/src/PageLoadingCommand.cpp

@@ -0,0 +1,46 @@
+#include "PageLoadingCommand.h"
+#include "Command.h"
+#include "WebPage.h"
+
+PageLoadingCommand::PageLoadingCommand(Command *command, WebPage *page, QObject *parent) : QObject(parent) {
+  m_page = page;
+  m_command = command;
+  m_pageLoadingFromCommand = false;
+  m_pageSuccess = true;
+  m_pendingResponse = NULL;
+  connect(m_page, SIGNAL(loadStarted()), this, SLOT(pageLoadingFromCommand()));
+  connect(m_page, SIGNAL(pageFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
+}
+
+void PageLoadingCommand::start() {
+  connect(m_command, SIGNAL(finished(Response *)), this, SLOT(commandFinished(Response *)));
+  m_command->start();
+};
+
+void PageLoadingCommand::pendingLoadFinished(bool success) {
+  m_pageSuccess = success;
+  if (m_pageLoadingFromCommand) {
+    m_pageLoadingFromCommand = false;
+    if (m_pendingResponse) {
+      if (m_pageSuccess) {
+        emit finished(m_pendingResponse);
+      } else {
+        QString message = m_page->failureString();
+        emit finished(new Response(false, message));
+      }
+    }
+  }
+}
+
+void PageLoadingCommand::pageLoadingFromCommand() {
+  m_pageLoadingFromCommand = true;
+}
+
+void PageLoadingCommand::commandFinished(Response *response) {
+  disconnect(m_page, SIGNAL(loadStarted()), this, SLOT(pageLoadingFromCommand()));
+  m_command->deleteLater();
+  if (m_pageLoadingFromCommand)
+    m_pendingResponse = response;
+  else
+    emit finished(response);
+}