intentmedia-capybara-webkit 0.7.2.1

data/src/Connection.cpp

@@ -0,0 +1,82 @@
+#include "Connection.h"
+#include "WebPage.h"
+#include "UnsupportedContentHandler.h"
+#include "CommandParser.h"
+#include "CommandFactory.h"
+#include "Command.h"
+
+#include <QTcpSocket>
+#include <iostream>
+
+Connection::Connection(QTcpSocket *socket, WebPage *page, QObject *parent) :
+    QObject(parent) {
+  m_socket = socket;
+  m_page = page;
+  m_commandParser = new CommandParser(socket, this);
+  m_commandFactory = new CommandFactory(page, this);
+  m_command = NULL;
+  m_pageSuccess = true;
+  m_commandWaiting = false;
+  connect(m_socket, SIGNAL(readyRead()), m_commandParser, SLOT(checkNext()));
+  connect(m_commandParser, SIGNAL(commandReady(QString, QStringList)), this, SLOT(commandReady(QString, QStringList)));
+  connect(m_page, SIGNAL(pageFinished(bool)), this, SLOT(pendingLoadFinished(bool)));
+}
+
+
+void Connection::commandReady(QString commandName, QStringList arguments) {
+  m_commandName = commandName;
+  m_arguments = arguments;
+
+  if (m_page->isLoading())
+    m_commandWaiting = true;
+  else
+    startCommand();
+}
+
+void Connection::startCommand() {
+  m_commandWaiting = false;
+  if (m_pageSuccess) {
+    m_command = m_commandFactory->createCommand(m_commandName.toAscii().constData());
+    if (m_command) {
+      connect(m_command,
+              SIGNAL(finished(Response *)),
+              this,
+              SLOT(finishCommand(Response *)));
+      m_command->start(m_arguments);
+    } else {
+      QString failure = QString("[Capybara WebKit] Unknown command: ") +  m_commandName + "\n";
+      writeResponse(new Response(false, failure));
+    }
+    m_commandName = QString();
+  } else {
+    m_pageSuccess = true;
+    QString message = m_page->failureString();
+    writeResponse(new Response(false, message));
+  }
+}
+
+void Connection::pendingLoadFinished(bool success) {
+  m_pageSuccess = success;
+  if (m_commandWaiting)
+    startCommand();
+}
+
+void Connection::finishCommand(Response *response) {
+  m_command->deleteLater();
+  m_command = NULL;
+  writeResponse(response);
+}
+
+void Connection::writeResponse(Response *response) {
+  if (response->isSuccess())
+    m_socket->write("ok\n");
+  else
+    m_socket->write("failure\n");
+
+  QByteArray messageUtf8 = response->message().toUtf8();
+  QString messageLength = QString::number(messageUtf8.size()) + "\n";
+  m_socket->write(messageLength.toAscii());
+  m_socket->write(messageUtf8);
+  delete response;
+}
+

data/src/Connection.h

@@ -0,0 +1,36 @@
+#include <QObject>
+#include <QStringList>
+
+class QTcpSocket;
+class WebPage;
+class Command;
+class Response;
+class CommandParser;
+class CommandFactory;
+
+class Connection : public QObject {
+  Q_OBJECT
+
+  public:
+    Connection(QTcpSocket *socket, WebPage *page, QObject *parent = 0);
+
+  public slots:
+    void commandReady(QString commandName, QStringList arguments);
+    void finishCommand(Response *response);
+    void pendingLoadFinished(bool success);
+
+  private:
+    void startCommand();
+    void writeResponse(Response *response);
+
+    QTcpSocket *m_socket;
+    QString m_commandName;
+    Command *m_command;
+    QStringList m_arguments;
+    WebPage *m_page;
+    CommandParser *m_commandParser;
+    CommandFactory *m_commandFactory;
+    bool m_pageSuccess;
+    bool m_commandWaiting;
+};
+

data/src/Evaluate.cpp

@@ -0,0 +1,84 @@
+#include "Evaluate.h"
+#include "WebPage.h"
+#include <iostream>
+
+Evaluate::Evaluate(WebPage *page, QObject *parent) : Command(page, parent) {
+  m_buffer = "";
+}
+
+void Evaluate::start(QStringList &arguments) {
+  QVariant result = page()->currentFrame()->evaluateJavaScript(arguments[0]);
+  addVariant(result);
+  emit finished(new Response(true, m_buffer));
+}
+
+void Evaluate::addVariant(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:
+        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;
+        }
+      default:
+        m_buffer.append("null");
+    }
+  } else {
+    m_buffer.append("null");
+  }
+}
+
+void Evaluate::addString(QString &string) {
+  QString escapedString(string);
+  escapedString.replace("\"", "\\\"");
+  m_buffer.append("\"");
+  m_buffer.append(escapedString);
+  m_buffer.append("\"");
+}
+
+void Evaluate::addArray(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 Evaluate::addMap(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("}");
+}

data/src/Evaluate.h

@@ -0,0 +1,22 @@
+#include "Command.h"
+
+#include <QVariantList>
+
+class WebPage;
+
+class Evaluate : public Command {
+  Q_OBJECT
+
+  public:
+    Evaluate(WebPage *page, QObject *parent = 0);
+    virtual void start(QStringList &arguments);
+
+  private:
+    void addVariant(QVariant &object);
+    void addString(QString &string);
+    void addArray(QVariantList &list);
+    void addMap(QVariantMap &map);
+
+    QString m_buffer;
+};
+

data/src/Execute.cpp

@@ -0,0 +1,16 @@
+#include "Execute.h"
+#include "WebPage.h"
+
+Execute::Execute(WebPage *page, QObject *parent) : Command(page, parent) {
+}
+
+void Execute::start(QStringList &arguments) {
+  QString script = arguments[0] + QString("; 'success'");
+  QVariant result = page()->currentFrame()->evaluateJavaScript(script);
+  if (result.isValid()) {
+    emit finished(new Response(true));
+  } else {
+    emit finished(new Response(false, "Javascript failed to execute"));
+  }
+}
+

data/src/Execute.h

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

data/src/Find.cpp

@@ -0,0 +1,19 @@
+#include "Find.h"
+#include "Command.h"
+#include "WebPage.h"
+
+Find::Find(WebPage *page, QObject *parent) : Command(page, parent) {
+}
+
+void Find::start(QStringList &arguments) {
+  QString message;
+  QVariant result = page()->invokeCapybaraFunction("find", arguments);
+
+  if (result.isValid()) {
+    message = result.toString();
+    emit finished(new Response(true, message));
+  } else {
+    emit finished(new Response(false, "Invalid XPath expression"));
+  }
+}
+

data/src/Find.h

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

data/src/FrameFocus.cpp

@@ -0,0 +1,66 @@
+#include "FrameFocus.h"
+#include "Command.h"
+#include "WebPage.h"
+
+FrameFocus::FrameFocus(WebPage *page, QObject *parent) : Command(page, parent) {
+}
+
+void FrameFocus::start(QStringList &arguments) {
+  findFrames();
+  switch(arguments.length()) {
+    case 1:
+      focusId(arguments[0]);
+      break;
+    case 2:
+      focusIndex(arguments[1].toInt());
+      break;
+    default:
+      focusParent();
+  }
+}
+
+void FrameFocus::findFrames() {
+  frames = page()->currentFrame()->childFrames();
+}
+
+void FrameFocus::focusIndex(int index) {
+  if (isFrameAtIndex(index)) {
+    frames[index]->setFocus();
+    success();
+  } else {
+    frameNotFound();
+  }
+}
+
+bool FrameFocus::isFrameAtIndex(int index) {
+  return 0 <= index && index < frames.length();
+}
+
+void FrameFocus::focusId(QString name) {
+  for (int i = 0; i < frames.length(); i++) {
+    if (frames[i]->frameName().compare(name) == 0) {
+      frames[i]->setFocus();
+      success();
+      return;
+    }
+  }
+
+  frameNotFound();
+}
+
+void FrameFocus::focusParent() {
+  if (page()->currentFrame()->parentFrame() == 0) {
+    emit finished(new Response(false, "Already at parent frame."));
+  } else {
+    page()->currentFrame()->parentFrame()->setFocus();
+    success();
+  }
+}
+
+void FrameFocus::frameNotFound() {
+  emit finished(new Response(false, "Unable to locate frame. "));
+}
+
+void FrameFocus::success() {
+  emit finished(new Response(true));
+}

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