intentmedia-capybara-webkit 0.7.2.1

data/src/Header.h

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

data/src/Headers.cpp

@@ -0,0 +1,11 @@
+#include "Headers.h"
+#include "WebPage.h"
+
+Headers::Headers(WebPage *page, QObject *parent) : Command(page, parent) {
+}
+
+void Headers::start(QStringList &arguments) {
+  Q_UNUSED(arguments);
+  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, QObject *parent = 0);
+    virtual void start(QStringList &arguments);
+};
+

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,25 @@
+#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);
+};
+

data/src/NetworkAccessManager.h

@@ -0,0 +1,18 @@
+#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);
+
+  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, QObject *parent) : Command(page, parent) {
+}
+
+void Node::start(QStringList &arguments) {
+  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, QObject *parent = 0);
+    virtual void start(QStringList &arguments);
+};
+

data/src/Render.cpp

@@ -0,0 +1,19 @@
+#include "Render.h"
+#include "WebPage.h"
+
+Render::Render(WebPage *page, QObject *parent) : Command(page, parent) {
+}
+
+void Render::start(QStringList &arguments) {
+  QStringList functionArguments(arguments);
+  QString imagePath = functionArguments.takeFirst();
+  int     width     = functionArguments.takeFirst().toInt();
+  int     height    = functionArguments.takeFirst().toInt();
+
+  QSize size(width, height);
+  page()->setViewportSize(size);
+
+  bool result = page()->render( imagePath );
+
+  emit finished(new Response(result));
+}

data/src/Render.h

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

data/src/Reset.cpp

@@ -0,0 +1,20 @@
+#include "Reset.h"
+#include "WebPage.h"
+#include "NetworkAccessManager.h"
+#include "NetworkCookieJar.h"
+
+Reset::Reset(WebPage *page, QObject *parent) : Command(page, parent) {
+}
+
+void Reset::start(QStringList &arguments) {
+  Q_UNUSED(arguments);
+
+  page()->triggerAction(QWebPage::Stop);
+  page()->currentFrame()->setHtml("<html><body></body></html>");
+  page()->networkAccessManager()->setCookieJar(new NetworkCookieJar());
+  page()->setCustomNetworkAccessManager();
+  page()->setUserAgent(NULL);
+  page()->resetResponseHeaders();
+  emit finished(new Response(true));
+}
+

data/src/Reset.h

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

data/src/Response.cpp

@@ -0,0 +1,19 @@
+#include "Response.h"
+#include <iostream>
+
+Response::Response(bool success, QString message) {
+  m_success = success;
+  m_message = message;
+}
+
+Response::Response(bool success) {
+  m_success = success;
+}
+
+bool Response::isSuccess() const {
+  return m_success;
+}
+
+QString Response::message() const {
+  return m_message;
+}

data/src/Response.h

@@ -0,0 +1,13 @@
+#include <QString>
+
+class Response {
+  public:
+    Response(bool success, QString message);
+    Response(bool success);
+    bool isSuccess() const;
+    QString message() const;
+
+  private:
+    bool m_success;
+    QString m_message;
+};

data/src/Server.cpp

@@ -0,0 +1,25 @@
+#include "Server.h"
+#include "WebPage.h"
+#include "Connection.h"
+
+#include <QTcpServer>
+
+Server::Server(QObject *parent, bool ignoreSslErrors) : QObject(parent) {
+  m_tcp_server = new QTcpServer(this);
+  m_page = new WebPage(this);
+  m_page->setIgnoreSslErrors(ignoreSslErrors);
+}
+
+bool Server::start() {
+  connect(m_tcp_server, SIGNAL(newConnection()), this, SLOT(handleConnection()));
+  return m_tcp_server->listen(QHostAddress::Any, 0);
+}
+
+quint16 Server::server_port() const {
+  return m_tcp_server->serverPort();
+}
+
+void Server::handleConnection() {
+  QTcpSocket *socket = m_tcp_server->nextPendingConnection();
+  new Connection(socket, m_page, this);
+}

data/src/Server.h

@@ -0,0 +1,21 @@
+#include <QObject>
+
+class QTcpServer;
+class WebPage;
+
+class Server : public QObject {
+  Q_OBJECT
+
+  public:
+    Server(QObject *parent, bool ignoreSslErrors);
+    bool start();
+    quint16 server_port() const;
+
+  public slots:
+    void handleConnection();
+
+  private:
+    QTcpServer *m_tcp_server;
+    WebPage *m_page;
+};
+

data/src/SetCookie.cpp

@@ -0,0 +1,18 @@
+#include "SetCookie.h"
+#include "WebPage.h"
+#include "NetworkCookieJar.h"
+#include <QNetworkCookie>
+
+SetCookie::SetCookie(WebPage *page, QObject *parent)
+  : Command(page, parent)
+{ }
+
+void SetCookie::start(QStringList &arguments)
+{
+  QList<QNetworkCookie> cookies = QNetworkCookie::parseCookies(arguments[0].toAscii());
+  NetworkCookieJar *jar = qobject_cast<NetworkCookieJar*>(page()
+                                                          ->networkAccessManager()
+                                                          ->cookieJar());
+  jar->overwriteCookies(cookies);
+  emit finished(new Response(true));
+}