imseng-capybara-webkit 0.12.1

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);
+}

data/src/PageLoadingCommand.h

@@ -0,0 +1,40 @@
+#include <QObject>
+#include <QStringList>
+
+class Command;
+class Response;
+class WebPage;
+
+/*
+ * Decorates a Command by deferring the finished() signal until any pending
+ * page loads are complete.
+ *
+ * If a Command starts a page load, no signal will be emitted until the page
+ * load is finished.
+ *
+ * If a pending page load fails, the command's response will be discarded and a
+ * failure response will be emitted instead.
+ */
+class PageLoadingCommand : public QObject {
+  Q_OBJECT
+
+  public:
+    PageLoadingCommand(Command *command, WebPage *page, QObject *parent = 0);
+    void start();
+
+  public slots:
+    void pageLoadingFromCommand();
+    void pendingLoadFinished(bool success);
+    void commandFinished(Response *response);
+
+  signals:
+    void finished(Response *response);
+
+  private:
+    WebPage *m_page;
+    Command *m_command;
+    Response *m_pendingResponse;
+    bool m_pageSuccess;
+    bool m_pageLoadingFromCommand;
+};
+

data/src/Render.cpp

@@ -0,0 +1,18 @@
+#include "Render.h"
+#include "WebPage.h"
+
+Render::Render(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Render::start() {
+  QString imagePath = arguments()[0];
+  int width = arguments()[1].toInt();
+  int height = arguments()[2].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, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+};

data/src/RequestedUrl.cpp

@@ -0,0 +1,12 @@
+#include "RequestedUrl.h"
+#include "WebPage.h"
+
+RequestedUrl::RequestedUrl(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void RequestedUrl::start() {
+  QUrl humanUrl = page()->currentFrame()->requestedUrl();
+  QByteArray encodedBytes = humanUrl.toEncoded();
+  emit finished(new Response(true, encodedBytes));
+}
+

data/src/RequestedUrl.h

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

data/src/Reset.cpp

@@ -0,0 +1,29 @@
+#include "Reset.h"
+#include "WebPage.h"
+#include "NetworkAccessManager.h"
+#include "NetworkCookieJar.h"
+
+Reset::Reset(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Reset::start() {
+  page()->triggerAction(QWebPage::Stop);
+
+  NetworkAccessManager* networkAccessManager = qobject_cast<NetworkAccessManager*>(page()->networkAccessManager());
+  networkAccessManager->setCookieJar(new NetworkCookieJar());
+  networkAccessManager->resetHeaders();
+
+  page()->setUserAgent(NULL);
+  page()->resetResponseHeaders();
+  page()->resetConsoleMessages();
+  page()->resetWindowSize();
+  resetHistory();
+  emit finished(new Response(true));
+}
+
+void Reset::resetHistory() {
+  // Clearing the history preserves the current history item, so set it to blank first.
+  page()->currentFrame()->setUrl(QUrl("about:blank"));
+  page()->history()->clear();
+}
+

data/src/Reset.h

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

data/src/ResizeWindow.cpp

@@ -0,0 +1,16 @@
+#include "ResizeWindow.h"
+#include "WebPage.h"
+
+ResizeWindow::ResizeWindow(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void ResizeWindow::start() {
+  int     width     = arguments()[0].toInt();
+  int     height    = arguments()[1].toInt();
+
+  QSize size(width, height);
+  page()->setViewportSize(size);
+
+  emit finished(new Response(true));
+}
+

data/src/ResizeWindow.h

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

data/src/Response.cpp

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

data/src/Response.h

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

data/src/Server.cpp

@@ -0,0 +1,24 @@
+#include "Server.h"
+#include "WebPage.h"
+#include "Connection.h"
+
+#include <QTcpServer>
+
+Server::Server(QObject *parent) : QObject(parent) {
+  m_tcp_server = new QTcpServer(this);
+  m_page = new WebPage(this);
+}
+
+bool Server::start() {
+  connect(m_tcp_server, SIGNAL(newConnection()), this, SLOT(handleConnection()));
+  return m_tcp_server->listen(QHostAddress::LocalHost, 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 start();
+    quint16 server_port() const;
+
+  public slots:
+    void handleConnection();
+
+  private:
+    QTcpServer *m_tcp_server;
+    WebPage *m_page;
+};
+

data/src/SetCookie.cpp

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

data/src/SetCookie.h

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

data/src/SetProxy.cpp

@@ -0,0 +1,22 @@
+#include "SetProxy.h"
+#include "WebPage.h"
+#include <QNetworkAccessManager>
+#include <QNetworkProxy>
+
+SetProxy::SetProxy(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {}
+
+void SetProxy::start()
+{
+  // default to empty proxy
+  QNetworkProxy proxy;
+
+  if (arguments().size() > 0)
+    proxy = QNetworkProxy(QNetworkProxy::HttpProxy,
+                          arguments()[0],
+                          (quint16)(arguments()[1].toInt()),
+                          arguments()[2],
+                          arguments()[3]);
+
+  page()->networkAccessManager()->setProxy(proxy);
+  emit finished(new Response(true));
+}

data/src/SetProxy.h

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

data/src/Source.cpp

@@ -0,0 +1,18 @@
+#include "Source.h"
+#include "WebPage.h"
+
+Source::Source(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Source::start() {
+  QNetworkAccessManager* accessManager = page()->networkAccessManager();
+  QNetworkRequest request(page()->currentFrame()->url());
+  reply = accessManager->get(request);
+
+  connect(reply, SIGNAL(finished()), this, SLOT(sourceLoaded()));
+}
+
+void Source::sourceLoaded() {
+  emit finished(new Response(true, reply->readAll()));
+}
+

data/src/Source.h

@@ -0,0 +1,19 @@
+#include "Command.h"
+
+class WebPage;
+class QNetworkReply;
+
+class Source : public Command {
+  Q_OBJECT
+
+  public:
+    Source(WebPage *page, QStringList &arguments, QObject *parent = 0);
+    virtual void start();
+
+  public slots:
+    void sourceLoaded();
+
+  private:
+    QNetworkReply *reply;
+};
+

data/src/Status.cpp

@@ -0,0 +1,12 @@
+#include "Status.h"
+#include "WebPage.h"
+#include <sstream>
+
+Status::Status(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Status::start() {
+  int status = page()->getLastStatus();
+  emit finished(new Response(true, QString::number(status)));
+}
+

data/src/Status.h

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

data/src/UnsupportedContentHandler.cpp

@@ -0,0 +1,32 @@
+#include "UnsupportedContentHandler.h"
+#include "WebPage.h"
+#include <QNetworkReply>
+
+UnsupportedContentHandler::UnsupportedContentHandler(WebPage *page, QNetworkReply *reply, QObject *parent) : QObject(parent) {
+  m_page = page;
+  m_reply = reply;
+  connect(m_reply, SIGNAL(finished()), this, SLOT(handleUnsupportedContent()));
+  disconnect(m_page, SIGNAL(loadFinished(bool)), m_page, SLOT(loadFinished(bool)));
+}
+
+void UnsupportedContentHandler::handleUnsupportedContent() {
+  QVariant contentMimeType = m_reply->header(QNetworkRequest::ContentTypeHeader);
+  if(contentMimeType.isNull()) {
+    this->finish(false);
+  } else {
+    this->loadUnsupportedContent();
+    this->finish(true);
+  }
+  this->deleteLater();
+}
+
+void UnsupportedContentHandler::loadUnsupportedContent() {
+    QByteArray text = m_reply->readAll();
+    m_page->mainFrame()->setContent(text, QString("text/plain"), m_reply->url());
+}
+
+void UnsupportedContentHandler::finish(bool success) {
+    connect(m_page, SIGNAL(loadFinished(bool)), m_page, SLOT(loadFinished(bool)));
+    m_page->replyFinished(m_reply);
+    m_page->loadFinished(success);
+}

data/src/UnsupportedContentHandler.h

@@ -0,0 +1,18 @@
+#include <QObject>
+class WebPage;
+class QNetworkReply;
+class UnsupportedContentHandler : public QObject {
+  Q_OBJECT
+
+  public:
+    UnsupportedContentHandler(WebPage *page, QNetworkReply *reply, QObject *parent = 0);
+
+  public slots:
+    void handleUnsupportedContent();
+
+  private:
+    WebPage *m_page;
+    QNetworkReply *m_reply;
+    void loadUnsupportedContent();
+    void finish(bool success);
+};

data/src/Url.cpp

@@ -0,0 +1,12 @@
+#include "Url.h"
+#include "WebPage.h"
+
+Url::Url(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Url::start() {
+  QUrl humanUrl = page()->currentFrame()->url();
+  QByteArray encodedBytes = humanUrl.toEncoded();
+  emit finished(new Response(true, encodedBytes));
+}
+

data/src/Url.h

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

data/src/Visit.cpp

@@ -0,0 +1,12 @@
+#include "Visit.h"
+#include "Command.h"
+#include "WebPage.h"
+
+Visit::Visit(WebPage *page, QStringList &arguments, QObject *parent) : Command(page, arguments, parent) {
+}
+
+void Visit::start() {
+  QUrl requestedUrl = QUrl::fromEncoded(arguments()[0].toUtf8(), QUrl::StrictMode);
+  page()->currentFrame()->load(QUrl(requestedUrl));
+  emit finished(new Response(true));
+}

data/src/Visit.h

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