rewrite log output

qml-player.pro

@@ -15,7 +15,8 @@ HEADERS += \
     src/cpp/rootstore.h \
     src/cpp/environment.h \
     src/cpp/quarkprocess.h \
-    src/cpp/either.h
+    src/cpp/either.h \
+    src/cpp/logger.h
 
 RESOURCES += qml.qrc
 

src/cpp/environment.cpp

@@ -8,12 +8,12 @@
 #include <QStringList>
 #include <QJsonObject>
 #include <QJsonDocument>
-#include <QDebug>
 #include <QStandardPaths>
 #include <QFileInfo>
 
 Environment::Environment(QStringList args, QObject *parent) : QObject(parent)
 {
+    this->out = new QTextStream(stdout);
     this->parser = new QCommandLineParser();
     this->env = QProcessEnvironment::systemEnvironment();
 
@@ -42,17 +42,16 @@ QString Environment::getBundledCommand(QString name) {
 QString Environment::getSystemCommand(QString name) {
     #if defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))
         QString files[] = {"/bin/", "/usr/bin/", "/usr/local/bin/"};
-        qDebug() << "files" << sizeof(files) << files;
+        this->printLine("files" + sizeof(files) + files);
         for( unsigned int i = 0; i < 3; i = i + 1 )
         {
-            qDebug() << "get " << name ;
+            this->printLine("get " + name);
             QString current = files[i] + name;
             QFileInfo info = QFileInfo(current);
             bool isFile = info.exists() && info.isFile();
             if(isFile) return current;
         }
     #endif
-
     return NULL;
 }
 
@@ -77,25 +76,26 @@ QString Environment::getCommand(QString name) {
     return info.isFile() && info.isExecutable() ? cmd : NULL;
 }
 
-QString Environment::getShellCommand(QString name) {
+QString Environment::getShellCommand(QString name) {    
     #if defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))
         QProcess proc;
         QString cmd = "which " + name;
         QString shell = env.value("SHELL", "/bin/bash");
         proc.start(shell, QStringList() << "-c" << cmd);
 
         if (!proc.waitForStarted()) {
-            qDebug() << "not started";
+            this->printLine("not started");
             return nullptr;
         }
 
         if (!proc.waitForFinished()) {
-            qDebug() << "not finished";
+            this->printLine("not finished);
                 return nullptr;
         }
 
         QString result =  proc.readAll(); // contains \n
         int n = result.size() - 1;
+        out.flush();
         return result.left(n);
     #else
         return NULL;
@@ -157,7 +157,7 @@ QProcessEnvironment Environment::getProcEnv() {
     if(nodePath != NULL)
         procEnv.insert("NODE_PATH", QDir::toNativeSeparators(nodePath));
     else
-        qDebug() << "could not set NODE_PATH";
+        this->printLine("could not set NODE_PATH\n");
 
     return procEnv;
 }
@@ -170,9 +170,8 @@ QuarkProcess* Environment::startProcess(QString path) {
     Either<QMap<QString, QString>, QJsonParseError> mayJson = this->loadJson(path);
 
     if(mayJson.is2nd()) {
-        qDebug() << "Could not parse: " << path <<
-                    "error: " << mayJson.as2nd().errorString();
-
+        this->printLine("Could not parse: " + path +
+                    "error: " + mayJson.as2nd().errorString());
         return nullptr;
     }
 
@@ -186,7 +185,7 @@ QuarkProcess* Environment::startProcess(QString path) {
                << "--configPath" << this->getConfigPath()
                << "--shellPath" << QCoreApplication::applicationFilePath();
 
-    QuarkProcess* proc = new QuarkProcess(this->getProcEnv(), this);
+    QuarkProcess* proc = new QuarkProcess(this->getProcEnv(), this, this);
 
     if(json.contains("initialQml")) proc->handleLoadQml(json.value("initialQml"));
 
@@ -213,8 +212,6 @@ Either<QMap<QString, QString>, QJsonParseError> Environment::loadJson(QString pa
     json = QJsonDocument::fromJson(data.toUtf8(), &err).object();
 
     if(err.error != QJsonParseError::NoError) {
-        qDebug() << "Could not parse: " << path <<
-                    "error: " << err.errorString();
         return some(err);
     }
 
@@ -248,3 +245,9 @@ QString Environment::hashPath(QString path) {
 
     return QString::number(hash);
 }
+
+void Environment::printLine(QString msg) {
+    this->out->operator <<(msg);
+    this->out->operator <<("\n");
+    this->out->flush();
+}

src/cpp/environment.h

@@ -10,14 +10,16 @@
 #include <QMap>
 #include <QDir>
 #include <QJsonParseError>
+#include <QTextStream>
 
 #include "quarkprocess.h"
 #include "either.h"
+#include "logger.h"
 
 Q_DECLARE_METATYPE(QJsonParseError)
 
 
-class Environment : public QObject
+class Environment : public QObject, Logger
 {
     Q_OBJECT
 public:
@@ -37,8 +39,11 @@ class Environment : public QObject
     QuarkProcess* startProcess(QString path);
     QuarkProcess* startProcess();
 
+    void printLine(QString msg);
+
 
 private:
+    QTextStream* out;
     QCommandLineParser* parser;
     QProcessEnvironment env;
     static QString hashPath(QString path);

src/cpp/logger.h

@@ -0,0 +1,14 @@
+#ifndef LOGGER_H
+#define LOGGER_H
+
+#include <QObject>
+#include <QString>
+
+class Logger
+{
+public:
+   virtual ~Logger() {}
+   virtual void printLine(QString msg) =0;
+};
+
+#endif // LOGGER_H

src/cpp/main.cpp

@@ -3,26 +3,23 @@
 #include <QtGui/QGuiApplication>
 #include <QObject>
 #include <QtDebug>
-#include <QTextStream>
 
 #include "quarkprocess.h"
 #include "environment.h"
 
 int main(int argc, char *argv[])
 {
-    QTextStream out(stderr);
     QGuiApplication app(argc, argv);
 
     Environment* env = new Environment(app.arguments());
     QuarkProcess* proc;
 
-    out << "\nnode:" << env->getCommand("node");
-    out << "\nNODE_PATH" << env->getProcEnv().value("NODE_PATH");
-    out << "\nscript:" << env->getScriptPath();
-    out << "\ndata:" << env->getDataPath().path();
-    out << "\nbundled app:" << env->getBundledAppPath();
+    env->printLine("node:" + env->getCommand("node"));
+    env->printLine("NODE_PATH" + env->getProcEnv().value("NODE_PATH"));
+    env->printLine("script:" + env->getScriptPath());
+    env->printLine("data:" + env->getDataPath().path());
+    env->printLine("bundled app:" + env->getBundledAppPath());
 
-    out.flush();
     if(env->getScriptPath() == "") {
         proc = env->startProcess(env->getBundledAppPath());
     } else {

src/cpp/quarkprocess.cpp

@@ -1,6 +1,5 @@
 #include "quarkprocess.h"
 
-#include <QDebug>
 #include <QCoreApplication>
 #include <QFileInfo>
 #include <QStandardPaths>
@@ -12,8 +11,9 @@
 
 #include "com/cutehacks/gel/gel.h"
 
-QuarkProcess::QuarkProcess(QProcessEnvironment env, QObject *parent) : QObject(parent)
+QuarkProcess::QuarkProcess(QProcessEnvironment env, Logger *log, QObject* parent) : QObject(parent)
 {
+    this->log = log;
     this->qmlEngine = new QQmlApplicationEngine(this);
     this->rootStore = new RootStore(this);
 
@@ -30,9 +30,10 @@ QuarkProcess::QuarkProcess(QProcessEnvironment env, QObject *parent) : QObject(p
     connect(&this->proc, &QProcess::readyReadStandardOutput, this, &QuarkProcess::onData);
     connect(this->rootStore, &RootStore::action, this, &QuarkProcess::onAction);
     connect(this, &QuarkProcess::loadQml, this, &QuarkProcess::handleLoadQml);
-    connect(&this->proc, &QProcess::errorOccurred, [=](const QProcess::ProcessError &error)  {
-        qDebug() << "error: " << error;
-    });
+    /*connect(&this->proc, &QProcess::errorOccurred, [ out ](const QProcess::ProcessError &error)  {
+        //out << QString("process error \n");
+        out.flush();
+    });*/
     connect(this->rootStore, &RootStore::data, [this](const QString &line)  {
         this->proc.write(line.toUtf8());
     });
@@ -55,7 +56,7 @@ void QuarkProcess::start(QString cmd, QStringList arguments) {
     if(info.isFile())
         this->proc.start(cmd, arguments);
     else
-        qDebug() << "could not find cmd: " << QDir::fromNativeSeparators(cmd);
+        this->log->printLine("could not find cmd: " + QDir::fromNativeSeparators(cmd));
 }
 
 void QuarkProcess::onData() {
@@ -70,7 +71,7 @@ void QuarkProcess::terminate() {
 }
 
 void QuarkProcess::handleLoadQml(QString path) {
-    qDebug() << "loadQml: " <<path;
+    this->log->printLine("loadQml: " + path);
     this->qmlEngine->load(QDir::toNativeSeparators(path));
 }
 

src/cpp/quarkprocess.h

@@ -9,20 +9,22 @@
 
 #include <QJsonValue>
 
+#include "logger.h"
 #include "rootstore.h"
 
 class QuarkProcess : public QObject
 {
     Q_OBJECT
 public:
-    explicit QuarkProcess(QProcessEnvironment, QObject *parent = 0);
+    explicit QuarkProcess(QProcessEnvironment, Logger *, QObject*);
 
 public slots:
     void start(QString path, QStringList arguments);
     void terminate();
     void handleLoadQml(QString path);
 
 private:
+    Logger* log;
     QProcess proc;
     QQmlApplicationEngine* qmlEngine;
     RootStore* rootStore;

src/cpp/rootstore.cpp

@@ -1,6 +1,6 @@
 #include "rootstore.h"
 
-#include <QDebug>
+#include <QTextStream>
 #include <QJsonDocument>
 #include <QJsonObject>
 
@@ -14,6 +14,7 @@ QJsonValue RootStore::value() {
 }
 
 void RootStore::writeData(QString data) {
+    QTextStream out(stderr);
     QJsonDocument doc = QJsonDocument::fromJson(data.toUtf8());
     QJsonObject msg = doc.object();
     QString type = msg.value("type").toString();
@@ -31,7 +32,8 @@ void RootStore::writeData(QString data) {
         return;
     }
 
-    qDebug() << "root store invalid line: " << data;
+    out << "root store invalid line: " << data;
+    out.flush();
 }
 
 void RootStore::trigger(QString type, QJsonValue payload) {