Merge branch 'master' into unit-testing

CMakeLists.txt

@@ -1,35 +1,5 @@
 cmake_minimum_required(VERSION 3.16)
 
-project(bsa_packer_tests)
-set(project_type tests)
-set(enable_warnings OFF)
-set(create_translations OFF)
-if(DEFINED DEPENDENCIES_DIR)
-	include(${DEPENDENCIES_DIR}/modorganizer_super/cmake_common/project.cmake)
-else()
-	include(../cmake_common/project.cmake)
-endif()
-add_subdirectory(tests)
-
-find_package(Qt5Concurrent REQUIRED)
-
-target_include_directories(${PROJECT_NAME}
-	PRIVATE
-		../src
-		${BOOST_DI_ROOT}/include)
-target_link_directories(${PROJECT_NAME}
-	PRIVATE
-		lib
-		src)
-target_link_libraries(${PROJECT_NAME}
-	Qt5::Concurrent
-	DirectXTex)
-requires_library(libbsarch)
-
-# Add include from the original src:
-target_include_directories(${PROJECT_NAME} PRIVATE src)
-
-
 project(bsa_packer)
 set(project_type plugin)
 set(enable_warnings OFF)
@@ -45,9 +15,6 @@ find_package(Qt5Concurrent REQUIRED)
 target_include_directories(${PROJECT_NAME} PRIVATE ${BOOST_DI_ROOT}/include)
 target_link_directories(${PROJECT_NAME} PRIVATE lib)
 target_link_libraries(${PROJECT_NAME}
-	Qt5::Concurrent
-	DirectXTex)
-requires_library(libbsarch)
-target_compile_definitions(bsa_packer PRIVATE BSAPACKER_LIBRARY)
-
-target_link_libraries(bsa_packer_tests bsa_packer)
+    Qt5::Concurrent
+    DirectXTex)
+requires_library(libbsarch)

appveyor.yml

@@ -9,8 +9,11 @@ build:
 build_script:
 - cmd: >-
     git clone --depth=1 --branch=%APPVEYOR_REPO_BRANCH% https://github.com/ModOrganizer2/modorganizer-umbrella.git c:\projects\modorganizer-umbrella 2> $null
+
     mkdir c:\projects\modorganizer-build -type directory
+
     cd c:\projects\modorganizer-umbrella
+
     C:\Python37-x64\python.exe unimake.py -d c:\projects\modorganizer-build -s Appveyor_Build=True %APPVEYOR_PROJECT_NAME%
 artifacts:
 - path: build\bsa_packer.dll

src/ArchiveAutoService.cpp

@@ -2,8 +2,9 @@
 
 namespace BsaPacker
 {
-	void ArchiveAutoService::CreateBSA(libbsarch::bs_archive_auto* archive, const QString& archiveName, const bsa_archive_type_e type) const
+	void ArchiveAutoService::CreateBSA(BSArchiveAuto* archive, const QString& archiveName, const bsa_archive_type_e type) const
 	{
-		archive->save_to_disk(archiveName.toStdString());
+		archive->create(archiveName, type);
+		archive->save();
 	}
 } // namespace BsaPacker

src/ArchiveBuilderFactory.cpp

@@ -40,11 +40,11 @@ namespace BsaPacker
 			case baTES4:
 			case baFO3:
 			case baSSE:
-				return std::make_unique<GeneralArchiveBuilder>(this->m_ArchiveBuilderHelper, modDto->Directory(), archiveType);
+				return std::make_unique<GeneralArchiveBuilder>(this->m_ArchiveBuilderHelper, modDto->Directory());
 			case baFO4:
-				return std::make_unique<TexturelessArchiveBuilder>(this->m_ArchiveBuilderHelper, modDto->Directory(), archiveType);
+				return std::make_unique<TexturelessArchiveBuilder>(this->m_ArchiveBuilderHelper, modDto->Directory());
 			case baFO4dds:
-				return std::make_unique<TextureArchiveBuilder>(this->m_ArchiveBuilderHelper, modDto->Directory(), archiveType);
+				return std::make_unique<TextureArchiveBuilder>(this->m_ArchiveBuilderHelper, modDto->Directory());
 			case baNone:
 			default:
 				return std::make_unique<NullArchiveBuilder>();

src/ArchiveBuilderHelper.cpp

@@ -1,12 +1,11 @@
 #include <bsapacker/ArchiveBuilderHelper.h>
 
-#include <algorithm>
-#include <boost/algorithm/string.hpp>
+#include <QDirIterator>
+#include <QtConcurrent/QtConcurrentMap>
+#include <QDebug>
 
 #include "SettingsService.h"
 
-#include <QDebug>
-
 using std::filesystem::is_directory;
 using std::filesystem::path;
 using std::filesystem::directory_entry;
@@ -21,32 +20,34 @@ namespace BsaPacker
 		: m_SettingsService(settingsService)
 	{
 	}
-	uint32_t ArchiveBuilderHelper::getFileCount(const path& rootDirectory) const
+	uint32_t ArchiveBuilderHelper::getFileCount(const QDir& rootDirectory) const
 	{
+		QDirIterator it(rootDirectory, QDirIterator::Subdirectories);
 		uint32_t count = 0;
-		for(auto& p : recursive_directory_iterator(rootDirectory)) {
+		while (it.hasNext()) {
+			it.next();
 			count++;
 		}
 		return count;
 	}
 
-	std::vector<path::string_type> ArchiveBuilderHelper::getRootDirectoryFilenames(const path& rootDirectory) const
+	QStringList ArchiveBuilderHelper::getRootDirectoryFilenames(const QDir& rootDirectory) const
 	{
-		std::vector<path::string_type> filenames;
-		for (const auto& entry : directory_iterator(rootDirectory)) {
-			filenames.push_back(entry.path().filename().native());
-		}
-		return filenames;
+		const std::function<QString(const QFileInfo&)> getFilename = [](const QFileInfo& fi) {
+			return fi.fileName();
+		};
+		return QtConcurrent::blockingMapped(rootDirectory.entryInfoList(QDir::Files),
+											getFilename);
 	}
 
-	bool ArchiveBuilderHelper::isFileIgnorable(const path& filepath, const std::vector<path::string_type>& rootDirFilenames) const
+	bool ArchiveBuilderHelper::isFileIgnorable(const QString& filepath, const QStringList& rootDirFilenames) const
 	{
 		return this->doesPathContainFiles(filepath, rootDirFilenames) || // ignore files within mod directory
 			is_directory(filepath) || // ignore directories
 			this->isExtensionBlacklisted(filepath); // ignore user blacklisted file types
 	}
 
-	bool ArchiveBuilderHelper::isIncompressible(const path& filename) const
+	bool ArchiveBuilderHelper::isIncompressible(const QString& filename) const
 	{
 		const auto& extension = filename.extension().string();
 		const auto& count = ArchiveBuilderHelper::INCOMPRESSIBLE_TYPES.count(extension);
@@ -65,9 +66,4 @@ namespace BsaPacker
 		const auto& result = count > 0;
 		return result;
 	}
-
-	bool ArchiveBuilderHelper::doesPathContainFiles(const path& filepath, const std::vector<path::string_type>& files) const
-	{
-		return std::find(files.begin(), files.end(), filepath.filename()) != files.end();
-	}
 } // namespace BsaPacker

src/ArchiveNameService.h

@@ -1,13 +1,12 @@
 #ifndef ARCHIVENAMESERVICE_H
 #define ARCHIVENAMESERVICE_H
 
-#include "bsapacker_global.h"
 #include <bsapacker/IArchiveNameService.h>
 #include <bsapacker/IModContext.h>
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT ArchiveNameService : public IArchiveNameService
+	class ArchiveNameService : public IArchiveNameService
 	{
 	public:
 		ArchiveNameService(const IModContext* modContext);

src/BsaPacker.cpp

@@ -12,7 +12,6 @@
 #include "HideLooseAssetService.h"
 #include "ModContext.h"
 #include "ModDto.h"
-#include "PackerDialog.h"
 #include "SettingsService.h"
 #include <bsapacker/ModDtoFactory.h>
 #include <QMessageBox>
@@ -89,8 +88,7 @@ namespace BsaPacker
 			di::bind<IFileWriterService>.to<FileWriterService>(),
 			di::bind<IArchiveNameService>.to<ArchiveNameService>(),
 			di::bind<IDummyPluginLogic>.to<DummyPluginLogic>(),
-			di::bind<IHideLooseAssetService>.to<HideLooseAssetService>(),
-			di::bind<IPackerDialog>.to<PackerDialog>()
+			di::bind<IHideLooseAssetService>.to<HideLooseAssetService>()
 		);
 
 		BsaPackerWorker worker = di::create<BsaPackerWorker>(injector);

src/BsaPacker.h

@@ -1,14 +1,13 @@
 #ifndef BSA_PACKER_H
 #define BSA_PACKER_H
 
-#include "bsapacker_global.h"
 #include <iplugintool.h>
 #include <bsapacker/IModContext.h>
 #include <bsapacker/ISettingsService.h>
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT Bsa_Packer : public MOBase::IPluginTool
+	class Bsa_Packer : public MOBase::IPluginTool
 	{
 		Q_OBJECT
 			Q_INTERFACES(MOBase::IPlugin MOBase::IPluginTool)

src/BsaPackerWorker.cpp

@@ -33,7 +33,7 @@ namespace BsaPacker
 			const std::unique_ptr<IArchiveBuilder> builder = this->m_ArchiveBuilderFactory->Create(type, modDto.get());
 			ArchiveBuildDirector director(this->m_SettingsService, builder.get());
 			director.Construct(); // must check if cancelled
-			const std::unique_ptr<libbsarch::bs_archive_auto> archive = builder->getArchive();
+			const std::unique_ptr<BSArchiveAuto> archive = builder->getArchive();
 			if (archive) {
 				const QString& archiveFullPath = this->m_ArchiveNameService->GetArchiveFullPath(type, modDto.get());
 				this->m_ArchiveAutoService->CreateBSA(archive.get(), archiveFullPath, type);

src/BsaPackerWorker.h

@@ -1,7 +1,6 @@
 #ifndef BSAPACKERWORKER_H
 #define BSAPACKERWORKER_H
 
-#include "bsapacker_global.h"
 #include <bsapacker/ISettingsService.h>
 #include <bsapacker/IModDtoFactory.h>
 #include <bsapacker/IArchiveBuilderFactory.h>
@@ -12,7 +11,7 @@
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT BsaPackerWorker
+	class BsaPackerWorker
 	{
 	public:
 		BsaPackerWorker(

src/DummyPluginServiceFactory.h

@@ -1,7 +1,6 @@
 #ifndef DUMMYPLUGINSERVICEFACTORY_H
 #define DUMMYPLUGINSERVICEFACTORY_H
 
-#include "bsapacker_global.h"
 #include <bsapacker/IDummyPluginLogic.h>
 #include <bsapacker/IDummyPluginServiceFactory.h>
 #include <bsapacker/IFileWriterService.h>
@@ -9,13 +8,13 @@
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT DummyPluginServiceFactory : public IDummyPluginServiceFactory
+	class DummyPluginServiceFactory : public IDummyPluginServiceFactory
 	{
 	public:
 		explicit DummyPluginServiceFactory(
 				const IModContext* modContext,
 				const IFileWriterService* fileWriterService, // bad! only passing this to another constructor!
-				const IDummyPluginLogic* dummyPluginLogic);  // TODO: perhaps remedy with strategy pattern?
+				const IDummyPluginLogic* dummyPluginLogic);  // perhaps remedy with strategy pattern?
 		~DummyPluginServiceFactory() override = default;
 		[[nodiscard]] std::unique_ptr<IDummyPluginService> Create() const override;
 

src/Fallout3DummyPluginService.h

@@ -1,14 +1,13 @@
 #ifndef FALLOUT3DUMMYPLUGINSERVICE_H
 #define FALLOUT3DUMMYPLUGINSERVICE_H
 
-#include "bsapacker_global.h"
 #include <bsapacker/IDummyPluginLogic.h>
 #include <bsapacker/IDummyPluginService.h>
 #include <bsapacker/IFileWriterService.h>
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT Fallout3DummyPluginService : public IDummyPluginService
+	class Fallout3DummyPluginService : public IDummyPluginService
 	{
 	public:
 		Fallout3DummyPluginService(const IFileWriterService* fileWriterService,

src/Fallout4DummyPluginService.h

@@ -1,14 +1,13 @@
 #ifndef FALLOUT4DUMMYPLUGINSERVICE_H
 #define FALLOUT4DUMMYPLUGINSERVICE_H
 
-#include "bsapacker_global.h"
 #include <bsapacker/IDummyPluginLogic.h>
 #include <bsapacker/IDummyPluginService.h>
 #include <bsapacker/IFileWriterService.h>
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT Fallout4DummyPluginService : public IDummyPluginService
+	class Fallout4DummyPluginService : public IDummyPluginService
 	{
 	public:
 		Fallout4DummyPluginService(const IFileWriterService* fileWriterService,

src/FileWriterService.h

@@ -1,15 +1,15 @@
 #ifndef FILEWRITERSERVICE_H
 #define FILEWRITERSERVICE_H
 
-#include "bsapacker_global.h"
 #include <bsapacker/IFileWriterService.h>
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT FileWriterService : public IFileWriterService
+	class FileWriterService : public IFileWriterService
 	{
 	public:
 		FileWriterService() = default;
+		~FileWriterService() override = default;
 		bool Write(const std::string& path, const char* payload, const uint32_t size) const override;
 	};
 }

src/GeneralArchiveBuilder.cpp

@@ -9,11 +9,11 @@ using namespace libbsarch;
 
 namespace BsaPacker
 {
-	GeneralArchiveBuilder::GeneralArchiveBuilder(const IArchiveBuilderHelper* archiveBuilderHelper, const QDir& rootDir, const bsa_archive_type_t& type)
+	GeneralArchiveBuilder::GeneralArchiveBuilder(const IArchiveBuilderHelper* archiveBuilderHelper, const QDir& rootDir)
 		: m_ArchiveBuilderHelper(archiveBuilderHelper), m_RootDirectory(rootDir)
 	{
 		this->m_Cancelled = false;
-		this->m_Archive = std::make_unique<libbsarch::bs_archive_auto>(type);
+		this->m_Archive = std::make_unique<BSArchiveAuto>(this->m_RootDirectory.path());
 	}
 
 	uint32_t GeneralArchiveBuilder::setFiles()
@@ -35,7 +35,7 @@ namespace BsaPacker
 			}
 
 			const QString& filepath = iterator.next();
-			const bool ignored = this->m_ArchiveBuilderHelper->isFileIgnorable(filepath.toStdWString(), rootDirFiles);
+			const bool ignored = this->m_ArchiveBuilderHelper->isFileIgnorable(filepath, rootDirFiles);
 
 			Q_EMIT this->valueChanged(++count);
 			if (ignored) {
@@ -49,23 +49,23 @@ namespace BsaPacker
 			this->m_Archive->add_file_from_disk(fileBlob);
 			qDebug() << "file is: " << filepath;
 		}
-		this->m_Archive->set_compressed(!static_cast<bool>(incompressibleFiles));
+		this->m_Archive->setCompressed(!static_cast<bool>(incompressibleFiles));
 		return incompressibleFiles + compressibleFiles;
 	}
 
 	void GeneralArchiveBuilder::setShareData(const bool value)
 	{
-		this->m_Archive->set_share_data(value);
+		this->m_Archive->setShareData(value);
 	}
 
-	std::unique_ptr<libbsarch::bs_archive_auto> GeneralArchiveBuilder::getArchive()
+	std::unique_ptr<BSArchiveAuto> GeneralArchiveBuilder::getArchive()
 	{
 		return std::move(this->m_Archive);
 	}
 
 	uint32_t GeneralArchiveBuilder::getFileCount() const
 	{
-		return this->m_ArchiveBuilderHelper->getFileCount(this->m_RootDirectory.path().toStdWString());
+		return this->m_ArchiveBuilderHelper->getFileCount(this->m_RootDirectory);
 	}
 
 	QString GeneralArchiveBuilder::getRootPath() const

src/HideLooseAssetService.h

@@ -1,16 +1,17 @@
 #ifndef HIDELOOSEASSETSERVICE_H
 #define HIDELOOSEASSETSERVICE_H
 
-#include "bsapacker_global.h"
 #include <bsapacker/IHideLooseAssetService.h>
 #include <bsapacker/ISettingsService.h>
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT HideLooseAssetService : public IHideLooseAssetService
+	class HideLooseAssetService : public IHideLooseAssetService
 	{
 	public:
+		HideLooseAssetService() = default;
 		HideLooseAssetService(const ISettingsService* settingsService);
+		~HideLooseAssetService() override = default;
 		bool HideLooseAssets(const QDir& modDirectory) const override;
 
 	private:

src/ModContext.h

@@ -1,16 +1,18 @@
 #ifndef MOD_CONTEXT_H
 #define MOD_CONTEXT_H
 
-#include "bsapacker_global.h"
 #include <bsapacker/IModContext.h>
 #include <imoinfo.h>
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT ModContext : public IModContext
+	class ModContext : public IModContext
 	{
 	public:
 		explicit ModContext(MOBase::IOrganizer* moInfo);
+		~ModContext() override = default;
+
+		// IModContext interface
 		[[nodiscard]] QString GetAbsoluteModPath(const QString& modName) const override;
 		[[nodiscard]] int GetNexusId() const override;
 		[[nodiscard]] QStringList GetPlugins(const QDir& modDirectory) const override;

src/ModDto.h

@@ -1,13 +1,14 @@
 #ifndef MODMETADTO_H
 #define MODMETADTO_H
 
-#include "bsapacker_global.h"
 #include <bsapacker/IModDto.h>
+
 #include <QDir>
+#include <QString>
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT ModDto : public IModDto
+	class ModDto : public IModDto
 	{
 	public:
 		ModDto(const int nexusId, const QString& modDir, const QString& archiveName, const QString& archiveExtension);

src/ModDtoFactory.cpp

@@ -10,28 +10,26 @@ namespace BsaPacker
 {
 	const uint16_t FALLOUT_4_NEXUS_ID = 1151;
 
-	ModDtoFactory::ModDtoFactory(
-		const IModContext* modContext,
-		IPackerDialog* packerDialog) :
-		m_ModContext(modContext),
-		m_PackerDialog(packerDialog)
+	ModDtoFactory::ModDtoFactory(const IModContext* modContext)
+		: m_ModContext(modContext)
 	{
 	}
 
 	std::unique_ptr<IModDto> ModDtoFactory::Create() const
 	{
-		this->m_PackerDialog->RefreshModList();
-		int result = m_PackerDialog->Exec();
+		PackerDialog packerDialog(this->m_ModContext);
+		packerDialog.RefreshModList();
+		int result = packerDialog.exec();
 		if (result != QDialog::DialogCode::Accepted)
 		{
 			return std::make_unique<NullModDto>();
 		}
 
 		const int nexusId = this->m_ModContext->GetNexusId();
-		const QString& modName = this->m_PackerDialog->SelectedMod();
+		const QString& modName = packerDialog.SelectedMod();
 		const QString& modDir = this->m_ModContext->GetAbsoluteModPath(modName);
-		const QString& pluginName = this->m_PackerDialog->SelectedPluginItem();
-		const bool needsNewName = this->m_PackerDialog->IsNewFilename();
+		const QString& pluginName = packerDialog.SelectedPluginItem();
+		const bool needsNewName = packerDialog.IsNewFilename();
 		const QString& archiveName = ModDtoFactory::ArchiveNameValidator(modName, pluginName, needsNewName);
 		const QString& archiveExtension = nexusId == FALLOUT_4_NEXUS_ID
 				? QStringLiteral(".ba2")

src/NewVegasDummyPluginService.h

@@ -1,14 +1,13 @@
 #ifndef NEWVEGASDUMMYPLUGINSERVICE_H
 #define NEWVEGASDUMMYPLUGINSERVICE_H
 
-#include "bsapacker_global.h"
 #include <bsapacker/IDummyPluginLogic.h>
 #include <bsapacker/IDummyPluginService.h>
 #include <bsapacker/IFileWriterService.h>
 
 namespace BsaPacker
 {
-	class BSAPACKER_EXPORT NewVegasDummyPluginService : public IDummyPluginService
+	class NewVegasDummyPluginService : public IDummyPluginService
 	{
 	public:
 		NewVegasDummyPluginService(const IFileWriterService* fileWriterService,