intentmedia-capybara-webkit 0.7.2.1

data/src/SetCookie.h

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

data/src/SetProxy.cpp

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

data/src/Source.cpp

@@ -0,0 +1,20 @@
+#include "Source.h"
+#include "WebPage.h"
+
+Source::Source(WebPage *page, QObject *parent) : Command(page, parent) {
+}
+
+void Source::start(QStringList &arguments) {
+  Q_UNUSED(arguments)
+
+  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, QObject *parent = 0);
+    virtual void start(QStringList &arguments);
+
+  public slots:
+    void sourceLoaded();
+
+  private:
+    QNetworkReply *reply;
+};
+

data/src/Status.cpp

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

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,15 @@
+#include "Url.h"
+#include "WebPage.h"
+
+Url::Url(WebPage *page, QObject *parent) : Command(page, parent) {
+}
+
+void Url::start(QStringList &argments) {
+  Q_UNUSED(argments);
+
+  QUrl humanUrl = page()->currentFrame()->url();
+  QByteArray encodedBytes = humanUrl.toEncoded();
+  QString urlString = QString(encodedBytes);
+  emit finished(new Response(true, urlString));
+}
+

data/src/Url.h

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

data/src/Visit.cpp

@@ -0,0 +1,21 @@
+#include "Visit.h"
+#include "Command.h"
+#include "WebPage.h"
+
+Visit::Visit(WebPage *page, QObject *parent) : Command(page, parent) {
+  connect(page, SIGNAL(pageFinished(bool)), this, SLOT(loadFinished(bool)));
+}
+
+void Visit::start(QStringList &arguments) {
+  QUrl requestedUrl = QUrl(arguments[0]);
+  page()->currentFrame()->load(QUrl(requestedUrl));
+}
+
+void Visit::loadFinished(bool success) {
+  QString message;
+  if (!success)
+    message = page()->failureString();
+
+  disconnect(page(), SIGNAL(pageFinished(bool)), this, SLOT(loadFinished(bool)));
+  emit finished(new Response(success, message));
+}

data/src/Visit.h

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

data/src/WebPage.cpp

@@ -0,0 +1,226 @@
+#include "WebPage.h"
+#include "JavascriptInvocation.h"
+#include "NetworkAccessManager.h"
+#include "NetworkCookieJar.h"
+#include "UnsupportedContentHandler.h"
+#include <QResource>
+#include <iostream>
+
+WebPage::WebPage(QObject *parent) : QWebPage(parent) {
+  setForwardUnsupportedContent(true);
+  loadJavascript();
+  setUserStylesheet();
+
+  m_loading = false;
+  this->setCustomNetworkAccessManager();
+
+  connect(this, SIGNAL(loadStarted()), this, SLOT(loadStarted()));
+  connect(this, SIGNAL(loadFinished(bool)), this, SLOT(loadFinished(bool)));
+  connect(this, SIGNAL(frameCreated(QWebFrame *)),
+          this, SLOT(frameCreated(QWebFrame *)));
+  connect(this, SIGNAL(unsupportedContent(QNetworkReply*)),
+      this, SLOT(handleUnsupportedContent(QNetworkReply*)));
+}
+
+void WebPage::setCustomNetworkAccessManager() {
+  NetworkAccessManager *manager = new NetworkAccessManager();
+  manager->setCookieJar(new NetworkCookieJar());
+  this->setNetworkAccessManager(manager);
+  connect(manager, SIGNAL(finished(QNetworkReply *)), this, SLOT(replyFinished(QNetworkReply *)));
+  connect(manager, SIGNAL(sslErrors(QNetworkReply *, QList<QSslError>)), this, SLOT(ignoreSslErrors(QNetworkReply *, QList<QSslError>)));
+}
+
+void WebPage::loadJavascript() {
+  QResource javascript(":/capybara.js");
+  if (javascript.isCompressed()) {
+    QByteArray uncompressedBytes(qUncompress(javascript.data(), javascript.size()));
+    m_capybaraJavascript = QString(uncompressedBytes);
+  } else {
+    char * javascriptString =  new char[javascript.size() + 1];
+    strcpy(javascriptString, (const char *)javascript.data());
+    javascriptString[javascript.size()] = 0;
+    m_capybaraJavascript = javascriptString;
+  }
+}
+
+void WebPage::setUserStylesheet() {
+  QString data = QString("* { font-family: 'Arial' ! important; }").toUtf8().toBase64();
+  QUrl url = QUrl(QString("data:text/css;charset=utf-8;base64,") + data);
+  settings()->setUserStyleSheetUrl(url);
+}
+
+QString WebPage::userAgentForUrl(const QUrl &url ) const {
+  if (!m_userAgent.isEmpty()) {
+    return m_userAgent;
+  } else {
+    return QWebPage::userAgentForUrl(url);
+  }
+}
+
+void WebPage::setUserAgent(QString userAgent) {
+  m_userAgent = userAgent;
+}
+
+void WebPage::frameCreated(QWebFrame * frame) {
+  connect(frame, SIGNAL(javaScriptWindowObjectCleared()),
+          this,  SLOT(injectJavascriptHelpers()));
+}
+
+void WebPage::injectJavascriptHelpers() {
+  QWebFrame* frame = qobject_cast<QWebFrame *>(QObject::sender());
+  frame->evaluateJavaScript(m_capybaraJavascript);
+}
+
+bool WebPage::shouldInterruptJavaScript() {
+  return false;
+}
+
+QVariant WebPage::invokeCapybaraFunction(const char *name, QStringList &arguments) {
+  QString qname(name);
+  QString objectName("CapybaraInvocation");
+  JavascriptInvocation invocation(qname, arguments);
+  currentFrame()->addToJavaScriptWindowObject(objectName, &invocation);
+  QString javascript = QString("Capybara.invoke()");
+  return currentFrame()->evaluateJavaScript(javascript);
+}
+
+QVariant WebPage::invokeCapybaraFunction(QString &name, QStringList &arguments) {
+  return invokeCapybaraFunction(name.toAscii().data(), arguments);
+}
+
+void WebPage::javaScriptConsoleMessage(const QString &message, int lineNumber, const QString &sourceID) {
+  if (!sourceID.isEmpty())
+    std::cout << qPrintable(sourceID) << ":" << lineNumber << " ";
+  std::cout << qPrintable(message) << std::endl;
+}
+
+void WebPage::javaScriptAlert(QWebFrame *frame, const QString &message) {
+  Q_UNUSED(frame);
+  std::cout << "ALERT: " << qPrintable(message) << std::endl;
+}
+
+bool WebPage::javaScriptConfirm(QWebFrame *frame, const QString &message) {
+  Q_UNUSED(frame);
+  Q_UNUSED(message);
+  return true;
+}
+
+bool WebPage::javaScriptPrompt(QWebFrame *frame, const QString &message, const QString &defaultValue, QString *result) {
+  Q_UNUSED(frame)
+  Q_UNUSED(message)
+  Q_UNUSED(defaultValue)
+  Q_UNUSED(result)
+  return false;
+}
+
+void WebPage::loadStarted() {
+  m_loading = true;
+}
+
+void WebPage::loadFinished(bool success) {
+  m_loading = false;
+  emit pageFinished(success);
+}
+
+bool WebPage::isLoading() const {
+  return m_loading;
+}
+
+QString WebPage::failureString() {
+  return QString("Unable to load URL: ") + currentFrame()->requestedUrl().toString();
+}
+
+bool WebPage::render(const QString &fileName) {
+  QFileInfo fileInfo(fileName);
+  QDir dir;
+  dir.mkpath(fileInfo.absolutePath());
+
+  QSize viewportSize = this->viewportSize();
+  QSize pageSize = this->mainFrame()->contentsSize();
+  if (pageSize.isEmpty()) {
+    return false;
+  }
+
+  QImage buffer(pageSize, QImage::Format_ARGB32);
+  buffer.fill(qRgba(255, 255, 255, 0));
+
+  QPainter p(&buffer);
+  p.setRenderHint( QPainter::Antialiasing,          true);
+  p.setRenderHint( QPainter::TextAntialiasing,      true);
+  p.setRenderHint( QPainter::SmoothPixmapTransform, true);
+
+  this->setViewportSize(pageSize);
+  this->mainFrame()->render(&p);
+  p.end();
+  this->setViewportSize(viewportSize);
+
+  return buffer.save(fileName);
+}
+
+QString WebPage::chooseFile(QWebFrame *parentFrame, const QString &suggestedFile) {
+  Q_UNUSED(parentFrame);
+  Q_UNUSED(suggestedFile);
+
+  return getLastAttachedFileName();
+}
+
+bool WebPage::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output) {
+  Q_UNUSED(option);
+  if (extension == ChooseMultipleFilesExtension) {
+    QStringList names = QStringList() << getLastAttachedFileName();
+    static_cast<ChooseMultipleFilesExtensionReturn*>(output)->fileNames = names;
+    return true;
+  }
+  return false;
+}
+
+QString WebPage::getLastAttachedFileName() {
+  return currentFrame()->evaluateJavaScript(QString("Capybara.lastAttachedFile")).toString();
+}
+
+void WebPage::replyFinished(QNetworkReply *reply) {
+  if (reply->url() == this->currentFrame()->url()) {
+    QStringList headers;
+    m_lastStatus = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    QList<QByteArray> list = reply->rawHeaderList();
+
+    int length = list.size();
+    for(int i = 0; i < length; i++) {
+      headers << list.at(i)+": "+reply->rawHeader(list.at(i));
+    }
+
+    m_pageHeaders = headers.join("\n");
+  }
+}
+
+void WebPage::ignoreSslErrors(QNetworkReply *reply, const QList<QSslError> &errors) {
+  if (m_ignoreSslErrors)
+    reply->ignoreSslErrors(errors);
+}
+
+void WebPage::setIgnoreSslErrors(bool ignore) {
+  m_ignoreSslErrors = ignore;
+}
+
+bool WebPage::ignoreSslErrors() {
+  return m_ignoreSslErrors;
+}
+
+
+int WebPage::getLastStatus() {
+  return m_lastStatus;
+}
+
+void WebPage::resetResponseHeaders() {
+  m_lastStatus = 0;
+  m_pageHeaders = QString();
+}
+
+QString WebPage::pageHeaders() {
+  return m_pageHeaders;
+}
+
+void WebPage::handleUnsupportedContent(QNetworkReply *reply) {
+  UnsupportedContentHandler *handler = new UnsupportedContentHandler(this, reply);
+  Q_UNUSED(handler);
+}