Move back test code

The code has never belonged into the BasicPluginsDeployer anyway. This
also makes calling the basic deployer's default code optional to
custom deployers.

This commit further puts a note in all existing deployers which call
the default deployment code for future developers.

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "lib/linuxdeploy"]
 	path = lib/linuxdeploy
 	url = https://github.com/TheAssassin/linuxdeploy
+[submodule "lib/googletest"]
+	path = lib/googletest
+	url = https://github.com/google/googletest.git

.travis.yml

@@ -1,33 +1,64 @@
 language: cpp
 sudo: required
+dist: xenial
 
-addons:
+matrix:
-  apt:
+  include:
-    update: true
+    - env: ARCH=x86_64
-    packages:
+      addons:
-      - libmagic-dev
+        apt:
-      - libmagick++-dev
+          update: true
-      - libboost-regex1.55-dev
+          sources:
-      - libboost-filesystem1.55-dev
+            - sourceline: 'ppa:beineri/opt-qt-5.12.3-xenial'
-      - automake  # required for patchelf
+          packages:
+            - libmagic-dev
+            - libjpeg-dev
+            - libpng-dev
+            - cimg-dev
+            - automake  # required for patchelf
+            - gcc
+            - g++
+            # Packages below are only required by the test srcipt
+            - qt512-meta-minimal
+            - qt512declarative
+            - qt512webengine
+            - mesa-common-dev
+            - libgl1-mesa-dev  # <-- that's for xenial to provide the x86_64-linux-gnu/libGL.so symlink
+            - # libglvnd-dev  # <-- that's for bionic to provide aforementioned symlink
+    - env: ARCH=i386
+      addons:
+        apt:
+          update: true
+          packages:
+            - libmagic-dev:i386
+            - libjpeg-dev:i386
+            - libpng-dev:i386
+            - automake  # required for patchelf
+            - libfuse2:i386
+            - libcairo2:i386
+            - gcc-multilib
+            - g++-multilib
 
 install:
-  - git clone https://github.com/NixOS/patchelf.git
+  - git clone https://github.com/NixOS/patchelf.git -b 0.8
   - cd patchelf
   - ./bootstrap.sh
-  - ./configure --prefix=/usr
+  - if [ "$ARCH" == "i386" ]; then export EXTRA_CONFIGURE_ARGS=("--build=i686-pc-linux-gnu" "CFLAGS=-m32" "CXXFLAGS=-m32" "LDFLAGS=-m32"); fi
+  - ./configure --prefix=/usr "${EXTRA_CONFIGURE_ARGS[@]}"
   - make -j$(nproc)
   - sudo make install
   - cd ..
   - rm -rf patchelf
 
 script:
-  - bash -xe travis/build-appimage.sh
+  - bash -xe travis/build.sh
+  # TODO: allow for cross-compiling the test projects and install i386 packages for build dependencies, then remove $ARCH check
+  - if [ "$ARCH" == "x86_64" ]; then bash -xe travis/test.sh linuxdeploy-plugin-qt-"$ARCH".AppImage; fi
 
 after_success:
   - ls -lh
   # make sure only pushes to rewrite create a new release, otherwise pretend PR and upload to transfer.sh
-  - if [ "$TRAVIS_BRANCH" != "master" ]; then export TRAVIS_EVENT_TYPE=pull_request; fi
+  - if [ "$TRAVIS_TAG" != "$TRAVIS_BRANCH" ] && [ "$TRAVIS_BRANCH" != "master" ]; then export TRAVIS_EVENT_TYPE=pull_request; fi
   - wget -c https://github.com/probonopd/uploadtool/raw/master/upload.sh
   - bash upload.sh linuxdeploy*.AppImage*
 

CMakeLists.txt

@@ -1,8 +1,14 @@
 cmake_minimum_required(VERSION 3.6)
 project(linuxdeploy-plugin-qt)
 
+include(CTest)
+
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 add_subdirectory(lib)
 add_subdirectory(src)
+
+if (BUILD_TESTING)
+  add_subdirectory(tests)
+endif()

README.md

@@ -2,4 +2,62 @@
 
 Plugin for linuxdeploy to bundle Qt dependencies of applications and libraries.
 
-***More information will follow soon!***
+
+## About
+
+linuxdeploy is a tool to create and maintain AppDirs, which can be turned into application bundles like AppImages.
+
+linuxdeploy-plugin-qt is a bundling plugin for linuxdeploy. If an application uses Qt, linuxdeploy-plugin-qt will bundle all the Qt plugins and resources such as QML files or translations.
+
+As linuxdeploy plugins are standalone applications, this software can also be run standalone. However, usage as a plugin from linuxdeploy is highly encouraged.
+
+
+## Usage
+
+As all linuxdeploy plugins, linuxdeploy-plugin-qt is a standalone tool implementing the so-called [Plugin Specification](https://github.com/linuxdeploy/linuxdeploy/wiki/Plugin-system). Therefore, there's two ways of using it: in "plugin mode" (i.e., together with linuxdeploy), or "standalone mode" (i.e., calling it directly).
+
+The most widely and also recommended method is to use it together with linuxdeploy.
+
+
+### Plugin mode
+
+Just download the plugin's official AppImage, and put it next to linuxdeploy's AppImage (alternatively, put it into one of the other [search locations](https://github.com/linuxdeploy/linuxdeploy/wiki/Plugin-system#plugin-discovery)). Make sure the AppImage is executable, otherwise it cannot be called by linuxdeploy.
+
+To enable the plugin, just call linuxdeploy as follows:
+
+```bash
+$ ./linuxdeploy-x86_64.AppImage --appdir AppDir [...] --plugin qt [...]
+```
+
+That's it! All you have to add is `--plugin qt`, and the plugin will be called by linuxdeploy.
+
+**Note:** If the application doesn't use Qt, linuxdeploy-plugin-qt will return an error. That's expected behavior, as it might help discover issues when a program is expected to use Qt but suddenly does not any more.
+
+
+### Standalone mode
+
+To use linuxdeploy-plugin-standalone, download the official AppImage, make it executable and run it like:
+
+```bash
+./linuxdeploy-plugin-qt-x86_64.AppImage --appdir AppDir
+```
+
+linuxdeploy-plugin-qt will look for Qt libraries in the library directory `usr/lib/` and deploy the Qt plugins and other resources for these. This means that if linuxdeploy or another tool haven't been run on the AppDir yet, i.e., no Qt libraries have been deployed yet, linuxdeploy-plugin-qt won't be able to recognize which plugins and resources have to be deployed, and will return an error.
+
+
+
+### Environment variables
+
+Just like all linuxdeploy plugins, the Qt plugin's behavior can be configured some environment variables.
+
+**General:**
+- `$DEBUG=1`: enables verbose output, useful for debugging (equal to linuxdeploy's `-v0`)
+- `$LD_LIBRARY_PATH=pathA:pathB`: Paths to check for library dependencies (see `man ld.so` for more information)
+
+**Qt specific:**
+- `$QMAKE=/path/to/my/qmake`: use another `qmake` binary to detect paths of plugins and other resources (usually doesn't need to be set manually, most Qt environments ship scripts changing `$PATH`)
+- `$EXTRA_QT_PLUGINS=pluginA;pluginB`: Plugins to deploy even if not found automatically by linuxdeploy-plugin-qt
+
+QML related:
+- `$QML_SOURCES_PATHS`: directory containing the application's QML files -- useful/needed if QML files are "baked" into the binaries
+- `$QML_MODULES_PATHS`: extra directories containing imported QML files (normally doesn't need to be specified)

cmake/toolchains/i386-linux-gnu.cmake

@@ -0,0 +1,7 @@
+set(CMAKE_SYSTEM_NAME Linux CACHE STRING "" FORCE)
+set(CMAKE_SYSTEM_PROCESSOR i386 CACHE STRING "" FORCE)
+
+set(CMAKE_C_FLAGS "-m32" CACHE STRING "" FORCE)
+set(CMAKE_CXX_FLAGS "-m32" CACHE STRING "" FORCE)
+
+set(THREADS_PTHREAD_ARG "2" CACHE STRING "Forcibly set by CMakeLists.txt." FORCE)

lib/CMakeLists.txt

@@ -1 +1,12 @@
 add_subdirectory(linuxdeploy EXCLUDE_FROM_ALL)
+if(NOT TARGET gtest AND BUILD_TESTING)
+    add_subdirectory(googletest EXCLUDE_FROM_ALL)
+endif()
+
+# required to properly build nlohmann/json v. 2.0.0 on trusty
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(json INTERFACE)
+set_property(TARGET json PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/json/include)
+target_sources(json INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/json/include/json.hpp)

resources/linuxdeploy-plugin-qt.desktop

@@ -5,3 +5,5 @@ Icon=linuxdeploy-plugin-qt
 Terminal=true
 NoDisplay=true
 Type=Application
+Categories=Development;
+X-AppImage-Integrate=false

src/CMakeLists.txt

@@ -1,7 +1,14 @@
-add_executable(linuxdeploy-plugin-qt main.cpp qt-modules.h)
+add_library(linuxdeploy-plugin-qt_util OBJECT util.cpp util.h)
-target_link_libraries(linuxdeploy-plugin-qt linuxdeploy_core args)
+target_include_directories(linuxdeploy-plugin-qt_util PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(linuxdeploy-plugin-qt_util linuxdeploy_core args)
+
+add_executable(linuxdeploy-plugin-qt main.cpp qt-modules.h qml.cpp qml.h deployment.h)
+target_link_libraries(linuxdeploy-plugin-qt linuxdeploy_core args json linuxdeploy-plugin-qt_util)
 set_target_properties(linuxdeploy-plugin-qt PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
 
+add_subdirectory(deployers)
+target_link_libraries(linuxdeploy-plugin-qt deployers)
+
 install(
     TARGETS linuxdeploy-plugin-qt
     RUNTIME DESTINATION bin

src/deployers/BasicPluginsDeployer.cpp

@@ -0,0 +1,33 @@
+// system headers
+#include <utility>
+
+// library headers
+#include <linuxdeploy/core/log.h>
+
+// local headers
+#include "BasicPluginsDeployer.h"
+
+using namespace linuxdeploy::core::log;
+using namespace linuxdeploy::core::appdir;
+using namespace linuxdeploy::plugin::qt;
+namespace bf = boost::filesystem;
+
+BasicPluginsDeployer::BasicPluginsDeployer(std::string moduleName,
+                                           core::appdir::AppDir& appDir,
+                                           bf::path qtPluginsPath,
+                                           bf::path qtLibexecsPath,
+                                           bf::path installLibsPath,
+                                           bf::path qtTranslationsPath,
+                                           bf::path qtDataPath) : moduleName(std::move(moduleName)),
+                                                                  appDir(appDir),
+                                                                  qtPluginsPath(std::move(qtPluginsPath)),
+                                                                  qtLibexecsPath(std::move(qtLibexecsPath)),
+                                                                  qtInstallQmlPath(std::move(installLibsPath)),
+                                                                  qtTranslationsPath(std::move(qtTranslationsPath)),
+                                                                  qtDataPath(std::move(qtDataPath)) {}
+
+bool BasicPluginsDeployer::deploy() {
+    // currently this is a no-op, but we might add more functionality later on, such as some kinds of default
+    // attempts to copy data based on the moduleName
+    return true;
+}

src/deployers/BasicPluginsDeployer.h

@@ -0,0 +1,55 @@
+#pragma once
+
+// system headers
+#include <memory>
+
+// library headers
+#include <linuxdeploy/core/appdir.h>
+
+// local headers
+#include "PluginsDeployer.h"
+
+
+namespace linuxdeploy {
+    namespace plugin {
+        namespace qt {
+            /**
+             *
+             */
+            class BasicPluginsDeployer : public PluginsDeployer {
+            protected:
+                std::string moduleName;
+                core::appdir::AppDir& appDir;
+
+                // Qt data
+                const boost::filesystem::path qtPluginsPath;
+                const boost::filesystem::path qtLibexecsPath;
+                const boost::filesystem::path qtInstallQmlPath;
+                const boost::filesystem::path qtTranslationsPath;
+                const boost::filesystem::path qtDataPath;
+
+            public:
+                /**
+                 * Default constructor. Constructs a basic deployer for a plugin with the given name.
+                 *
+                 * @param moduleName
+                 */
+                explicit BasicPluginsDeployer(std::string moduleName, core::appdir::AppDir& appDir,
+                                              boost::filesystem::path qtPluginsPath,
+                                              boost::filesystem::path qtLibexecsPath,
+                                              boost::filesystem::path installLibsPath,
+                                              boost::filesystem::path qtTranslationsPath,
+                                              boost::filesystem::path qtDataPath);
+
+                /**
+                 * Default destroyer is good enough for this class for now, but in case we need to change this we declare a virtual
+                 * one.
+                 */
+                virtual ~BasicPluginsDeployer() = default;
+
+            public:
+                bool deploy() override;
+            };
+        }
+    }
+}

src/deployers/BearerPluginsDeployer.cpp

@@ -0,0 +1,26 @@
+// library headers
+#include <linuxdeploy/core/log.h>
+#include <boost/filesystem.hpp>
+
+// local headers
+#include "BearerPluginsDeployer.h"
+
+using namespace linuxdeploy::plugin::qt;
+using namespace linuxdeploy::core::log;
+
+namespace bf = boost::filesystem;
+
+bool BearerPluginsDeployer::deploy() {
+    // calling the default code is optional, but it won't hurt for now
+    if (!BasicPluginsDeployer::deploy())
+        return false;
+
+    ldLog() << "Deploying bearer plugins" << std::endl;
+
+    for (bf::directory_iterator i(qtPluginsPath / "bearer"); i != bf::directory_iterator(); ++i) {
+        if (!appDir.deployLibrary(*i, appDir.path() / "usr/plugins/bearer/"))
+            return false;
+    }
+
+    return true;
+}

src/deployers/BearerPluginsDeployer.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "BasicPluginsDeployer.h"
+
+namespace linuxdeploy {
+    namespace plugin {
+        namespace qt {
+            class BearerPluginsDeployer : public BasicPluginsDeployer {
+            public:
+                // we can just use the base class's constructor
+                using BasicPluginsDeployer::BasicPluginsDeployer;
+
+                bool deploy() override;
+            };
+        }
+    }
+}

src/deployers/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.1)
+
+set(CLASSES
+    PluginsDeployer
+    PluginsDeployerFactory
+    BasicPluginsDeployer
+
+    PlatformPluginsDeployer
+    XcbglIntegrationPluginsDeployer
+    BearerPluginsDeployer
+    SvgPluginsDeployer
+    SqlPluginsDeployer
+    PositioningPluginsDeployer
+    MultimediaPluginsDeployer
+    WebEnginePluginsDeployer
+    QmlPluginsDeployer
+    Qt3DPluginsDeployer
+    GamepadPluginsDeployer
+)
+
+add_library(deployers OBJECT)
+
+target_link_libraries(deployers PUBLIC linuxdeploy_core linuxdeploy-plugin-qt_util)
+
+foreach(class ${CLASSES})
+    target_sources(deployers PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/${class}.h)
+    target_sources(deployers PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/${class}.cpp)
+endforeach()

src/deployers/GamepadPluginsDeployer.cpp

@@ -0,0 +1,26 @@
+// library headers
+#include <linuxdeploy/core/log.h>
+#include <boost/filesystem.hpp>
+
+// local headers
+#include "GamepadPluginsDeployer.h"
+
+using namespace linuxdeploy::plugin::qt;
+using namespace linuxdeploy::core::log;
+
+namespace bf = boost::filesystem;
+
+bool GamepadPluginsDeployer::deploy() {
+    // calling the default code is optional, but it won't hurt for now
+    if (!BasicPluginsDeployer::deploy())
+        return false;
+
+    ldLog() << "Deploying Gamepad plugins" << std::endl;
+
+    for (bf::directory_iterator i(qtPluginsPath / "gamepads"); i != bf::directory_iterator(); ++i) {
+        if (!appDir.deployLibrary(*i, appDir.path() / "usr/plugins/gamepads/"))
+            return false;
+    }
+
+    return true;
+}

src/deployers/GamepadPluginsDeployer.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "BasicPluginsDeployer.h"
+
+namespace linuxdeploy {
+    namespace plugin {
+        namespace qt {
+            class GamepadPluginsDeployer : public BasicPluginsDeployer {
+            public:
+                // we can just use the base class's constructor
+                using BasicPluginsDeployer::BasicPluginsDeployer;
+
+                bool deploy() override;
+            };
+        }
+    }
+}

src/deployers/MultimediaPluginsDeployer.cpp

@@ -0,0 +1,33 @@
+// library headers
+#include <linuxdeploy/core/log.h>
+#include <boost/filesystem.hpp>
+
+// local headers
+#include "MultimediaPluginsDeployer.h"
+
+using namespace linuxdeploy::plugin::qt;
+using namespace linuxdeploy::core::log;
+
+namespace bf = boost::filesystem;
+
+bool MultimediaPluginsDeployer::deploy() {
+    // calling the default code is optional, but it won't hurt for now
+    if (!BasicPluginsDeployer::deploy())
+        return false;
+
+    ldLog() << "Deploying mediaservice plugins" << std::endl;
+
+    for (bf::directory_iterator i(qtPluginsPath / "mediaservice"); i != bf::directory_iterator(); ++i) {
+        if (!appDir.deployLibrary(*i, appDir.path() / "usr/plugins/mediaservice/"))
+            return false;
+    }
+
+    ldLog() << "Deploying audio plugins" << std::endl;
+
+    for (bf::directory_iterator i(qtPluginsPath / "audio"); i != bf::directory_iterator(); ++i) {
+        if (!appDir.deployLibrary(*i, appDir.path() / "usr/plugins/audio/"))
+            return false;
+    }
+
+    return true;
+}

src/deployers/MultimediaPluginsDeployer.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "BasicPluginsDeployer.h"
+
+namespace linuxdeploy {
+    namespace plugin {
+        namespace qt {
+            class MultimediaPluginsDeployer : public BasicPluginsDeployer {
+            public:
+                // we can just use the base class's constructor
+                using BasicPluginsDeployer::BasicPluginsDeployer;
+
+                bool deploy() override;
+            };
+        }
+    }
+}