MultiMC/quazip
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Ability to compress hidden files when compressing directories

Browse source
This commit is contained in:
alqualos 2015-11-18 18:27:40 +00:00
parent 159bece5db
commit e35ef9c5a1
5 changed files with 60 additions and 137 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
quazip/Doxyfile
View file

@ -610,7 +610,7 @@ WARN_LOGFILE =
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.
INPUT =
INPUT = quazip doc
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
@ -1491,7 +1491,7 @@ SKIP_FUNCTION_MACROS = YES
# If a tag file is not located in the directory in which doxygen
# is run, you must also specify the path to the tagfile here.
TAGFILES =
TAGFILES = qtcore.tags=http://doc.qt.io/qt-5/
# When a file name is specified after GENERATE_TAGFILE, doxygen will create
# a tag file that is based on the input files it reads.

143
quazip/quazip/JlCompress.cpp
View file

@ -39,17 +39,6 @@ static bool copyData(QIODevice &inFile, QIODevice &outFile)
return true;
}
/**OK
* Comprime il file fileName, nell'oggetto zip, con il nome fileDest.
*
* La funzione fallisce se:
* * zip==NULL;
* * l'oggetto zip e stato aperto in una modalita non compatibile con l'aggiunta di file;
* * non e possibile aprire il file d'origine;
* * non e possibile creare il file all'interno dell'oggetto zip;
* * si e rilevato un errore nella copia dei dati;
* * non e stato possibile chiudere il file all'interno dell'oggetto zip;
*/
bool JlCompress::compressFile(QuaZip* zip, QString fileName, QString fileDest) {
// zip: oggetto dove aggiungere il file
// fileName: nome del file reale
@ -83,24 +72,7 @@ bool JlCompress::compressFile(QuaZip* zip, QString fileName, QString fileDest) {
return true;
}
/**OK
* Comprime la cartella dir nel file fileCompressed, se recursive e true allora
* comprime anche le sotto cartelle. I nomi dei file preceduti dal path creato
* togliendo il pat della cartella origDir al path della cartella dir.
* Se la funzione fallisce restituisce false e cancella il file che si e tentato
* di creare.
*
* La funzione fallisce se:
* * zip==NULL;
* * l'oggetto zip e stato aperto in una modalita non compatibile con l'aggiunta di file;
* * la cartella dir non esiste;
* * la compressione di una sotto cartella fallisce (1);
* * la compressione di un file fallisce;
* (1) La funzione si richiama in maniera ricorsiva per comprimere le sotto cartelle
* dunque gli errori di compressione di una sotto cartella sono gli stessi di questa
* funzione.
*/
bool JlCompress::compressSubDir(QuaZip* zip, QString dir, QString origDir, bool recursive) {
bool JlCompress::compressSubDir(QuaZip* zip, QString dir, QString origDir, bool recursive, QDir::Filters filters) {
// zip: oggetto dove aggiungere il file
// dir: cartella reale corrente
// origDir: cartella reale originale
@ -130,15 +102,15 @@ bool JlCompress::compressSubDir(QuaZip* zip, QString dir, QString origDir, bool
// Se comprimo anche le sotto cartelle
if (recursive) {
// Per ogni sotto cartella
QFileInfoList files = directory.entryInfoList(QDir::AllDirs|QDir::NoDotAndDotDot);
QFileInfoList files = directory.entryInfoList(QDir::AllDirs|QDir::NoDotAndDotDot|filters);
Q_FOREACH (QFileInfo file, files) {
// Comprimo la sotto cartella
if(!compressSubDir(zip,file.absoluteFilePath(),origDir,recursive)) return false;
if(!compressSubDir(zip,file.absoluteFilePath(),origDir,recursive,filters)) return false;
}
}
// Per ogni file nella cartella
QFileInfoList files = directory.entryInfoList(QDir::Files);
QFileInfoList files = directory.entryInfoList(QDir::Files|filters);
Q_FOREACH (QFileInfo file, files) {
// Se non e un file o e il file compresso che sto creando
if(!file.isFile()||file.absoluteFilePath()==zip->getZipName()) continue;
@ -153,20 +125,6 @@ bool JlCompress::compressSubDir(QuaZip* zip, QString dir, QString origDir, bool
return true;
}
/**OK
* Estrae il file fileName, contenuto nell'oggetto zip, con il nome fileDest.
* Se la funzione fallisce restituisce false e cancella il file che si e tentato di estrarre.
*
* La funzione fallisce se:
* * zip==NULL;
* * l'oggetto zip e stato aperto in una modalita non compatibile con l'estrazione di file;
* * non e possibile aprire il file all'interno dell'oggetto zip;
* * non e possibile creare il file estratto;
* * si e rilevato un errore nella copia dei dati (1);
* * non e stato possibile chiudere il file all'interno dell'oggetto zip (1);
*
* (1): prima di uscire dalla funzione cancella il file estratto.
*/
bool JlCompress::extractFile(QuaZip* zip, QString fileName, QString fileDest) {
// zip: oggetto dove aggiungere il file
// filename: nome del file reale
@ -232,12 +190,6 @@ bool JlCompress::extractFile(QuaZip* zip, QString fileName, QString fileDest) {
return true;
}
/**
* Rimuove i file il cui nome e specificato all'interno di listFile.
* Restituisce true se tutti i file sono stati cancellati correttamente, attenzione
* perche puo restituire false anche se alcuni file non esistevano e si e tentato
* di cancellarli.
*/
bool JlCompress::removeFile(QStringList listFile) {
bool ret = true;
// Per ogni file
@ -248,18 +200,6 @@ bool JlCompress::removeFile(QStringList listFile) {
return ret;
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/**OK
* Comprime il file fileName nel file fileCompressed.
* Se la funzione fallisce restituisce false e cancella il file che si e tentato
* di creare.
*
* La funzione fallisce se:
* * non si riesce ad aprire l'oggetto zip;
* * la compressione del file fallisce;
* * non si riesce a chiudere l'oggetto zip;
*/
bool JlCompress::compressFile(QString fileCompressed, QString file) {
// Creo lo zip
QuaZip zip(fileCompressed);
@ -285,16 +225,6 @@ bool JlCompress::compressFile(QString fileCompressed, QString file) {
return true;
}
/**OK
* Comprime i file specificati in files nel file fileCompressed.
* Se la funzione fallisce restituisce false e cancella il file che si e tentato
* di creare.
*
* La funzione fallisce se:
* * non si riesce ad aprire l'oggetto zip;
* * la compressione di un file fallisce;
* * non si riesce a chiudere l'oggetto zip;
*/
bool JlCompress::compressFiles(QString fileCompressed, QStringList files) {
// Creo lo zip
QuaZip zip(fileCompressed);
@ -324,18 +254,13 @@ bool JlCompress::compressFiles(QString fileCompressed, QStringList files) {
return true;
}
/**OK
* Comprime la cartella dir nel file fileCompressed, se recursive e true allora
* comprime anche le sotto cartelle.
* Se la funzione fallisce restituisce false e cancella il file che si e tentato
* di creare.
*
* La funzione fallisce se:
* * non si riesce ad aprire l'oggetto zip;
* * la compressione di un file fallisce;
* * non si riesce a chiudere l'oggetto zip;
*/
bool JlCompress::compressDir(QString fileCompressed, QString dir, bool recursive) {
return compressDir(fileCompressed, dir, recursive, 0);
}
bool JlCompress::compressDir(QString fileCompressed, QString dir,
bool recursive, QDir::Filters filters)
{
// Creo lo zip
QuaZip zip(fileCompressed);
QDir().mkpath(QFileInfo(fileCompressed).absolutePath());
@ -345,7 +270,7 @@ bool JlCompress::compressDir(QString fileCompressed, QString dir, bool recursive
}
// Aggiungo i file e le sotto cartelle
if (!compressSubDir(&zip,dir,dir,recursive)) {
if (!compressSubDir(&zip,dir,dir,recursive, filters)) {
QFile::remove(fileCompressed);
return false;
}
@ -360,20 +285,6 @@ bool JlCompress::compressDir(QString fileCompressed, QString dir, bool recursive
return true;
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/**OK
* Estrae il file fileName, contenuto nel file fileCompressed, con il nome fileDest.
* Se fileDest = "" allora il file viene estratto con lo stesso nome con cui e
* stato compresso.
* Se la funzione fallisce cancella il file che si e tentato di estrarre.
* Restituisce il nome assoluto del file estratto.
*
* La funzione fallisce se:
* * non si riesce ad aprire l'oggetto zip;
* * l'estrazione del file fallisce;
* * non si riesce a chiudere l'oggetto zip;
*/
QString JlCompress::extractFile(QString fileCompressed, QString fileName, QString fileDest) {
// Apro lo zip
QuaZip zip(fileCompressed);
@ -397,18 +308,6 @@ QString JlCompress::extractFile(QString fileCompressed, QString fileName, QStrin
return QFileInfo(fileDest).absoluteFilePath();
}
/**OK
* Estrae i file specificati in files, contenuti nel file fileCompressed, nella
* cartella dir. La struttura a cartelle del file compresso viene rispettata.
* Se dir = "" allora il file viene estratto nella cartella corrente.
* Se la funzione fallisce cancella i file che si e tentato di estrarre.
* Restituisce i nomi assoluti dei file estratti.
*
* La funzione fallisce se:
* * non si riesce ad aprire l'oggetto zip;
* * l'estrazione di un file fallisce;
* * non si riesce a chiudere l'oggetto zip;
*/
QStringList JlCompress::extractFiles(QString fileCompressed, QStringList files, QString dir) {
// Creo lo zip
QuaZip zip(fileCompressed);
@ -437,17 +336,6 @@ QStringList JlCompress::extractFiles(QString fileCompressed, QStringList files,
return extracted;
}
/**OK
* Estrae il file fileCompressed nella cartella dir.
* Se dir = "" allora il file viene estratto nella cartella corrente.
* Se la funzione fallisce cancella i file che si e tentato di estrarre.
* Restituisce i nomi assoluti dei file estratti.
*
* La funzione fallisce se:
* * non si riesce ad aprire l'oggetto zip;
* * la compressione di un file fallisce;
* * non si riesce a chiudere l'oggetto zip;
*/
QStringList JlCompress::extractDir(QString fileCompressed, QString dir) {
// Apro lo zip
QuaZip zip(fileCompressed);
@ -480,15 +368,6 @@ QStringList JlCompress::extractDir(QString fileCompressed, QString dir) {
return extracted;
}
/**OK
* Restituisce la lista dei file resenti nel file compresso fileCompressed.
* Se la funzione fallisce, restituisce un elenco vuoto.
*
* La funzione fallisce se:
* * non si riesce ad aprire l'oggetto zip;
* * la richiesta di informazioni di un file fallisce;
* * non si riesce a chiudere l'oggetto zip;
*/
QStringList JlCompress::getFileList(QString fileCompressed) {
// Apro lo zip
QuaZip* zip = new QuaZip(QFileInfo(fileCompressed).absoluteFilePath());

23
quazip/quazip/JlCompress.h
View file

@ -59,7 +59,8 @@ private:
files.
\return true if success, false otherwise.
*/
static bool compressSubDir(QuaZip* parentZip, QString dir, QString parentDir, bool recursive = true);
static bool compressSubDir(QuaZip* parentZip, QString dir, QString parentDir, bool recursive,
QDir::Filters filters);
/// Extract a single file.
/**
\param zip The opened zip archive to extract from.
@ -92,6 +93,8 @@ public:
static bool compressFiles(QString fileCompressed, QStringList files);
/// Compress a whole directory.
/**
Does not compress hidden files. See compressDir(QString, QString, bool, QDir::Filters).
\param fileCompressed The name of the archive.
\param dir The directory to compress.
\param recursive Whether to pack the subdirectories as well, or
@ -99,6 +102,24 @@ public:
\return true if success, false otherwise.
*/
static bool compressDir(QString fileCompressed, QString dir = QString(), bool recursive = true);
/**
* @brief Compress a whole directory.
*
* Unless filters are specified explicitly, packs
* only regular non-hidden files (and subdirs, if @c recursive is true).
* If filters are specified, they are OR-combined with
* <tt>%QDir::AllDirs|%QDir::NoDotAndDotDot</tt> when searching for dirs
* and with <tt>QDir::Files</tt> when searching for files.
*
* @param fileCompressed path to the resulting archive
* @param dir path to the directory being compressed
* @param recursive if true, then the subdirectories are packed as well
* @param filters what to pack, filters are applied both when searching
* for subdirs (if packing recursively) and when looking for files to pack
* @return true on success, false otherwise
*/
static bool compressDir(QString fileCompressed, QString dir,
bool recursive, QDir::Filters filters);
public:
/// Extract a single file.

2
quazip/quazip/qioapi.cpp
View file

@ -75,6 +75,7 @@ ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream
}
}
/// @cond internal
struct QIODevice_descriptor {
// Position only used for writing to sequential devices.
qint64 pos;
@ -82,6 +83,7 @@ struct QIODevice_descriptor {
pos(0)
{}
};
/// @endcond
voidpf ZCALLBACK qiodevice_open_file_func (
voidpf opaque,

23
quazip/qztest/testjlcompress.cpp
View file

@ -33,6 +33,10 @@ see quazip/(un)zip.h files for details. Basically it's the zlib license.
#include <quazip/JlCompress.h>
#ifdef Q_OS_WIN
#include <Windows.h>
#endif
void TestJlCompress::compressFile_data()
{
QTest::addColumn<QString>("zipName");
@ -101,24 +105,32 @@ void TestJlCompress::compressDir_data()
{
QTest::addColumn<QString>("zipName");
QTest::addColumn<QStringList>("fileNames");
QTest::addColumn<QList<int>>("attributes");
QTest::addColumn<QStringList>("expected");
QTest::newRow("simple") << "jldir.zip"
<< (QStringList() << "test0.txt" << "testdir1/test1.txt"
<< "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
<< QList<int>()
<< (QStringList() << "test0.txt"
<< "testdir1/" << "testdir1/test1.txt"
<< "testdir2/" << "testdir2/test2.txt"
<< "testdir2/subdir/" << "testdir2/subdir/test2sub.txt");
QTest::newRow("empty dirs") << "jldir_empty.zip"
<< (QStringList() << "testdir1/" << "testdir2/testdir3/")
<< QList<int>()
<< (QStringList() << "testdir1/" << "testdir2/"
<< "testdir2/testdir3/");
QTest::newRow("hidden files") << "jldir_hidden.zip"
<< (QStringList() << ".test0.txt" << "test1.txt")
<< (QList<int>() << QDir::Hidden << QDir::Files)
<< (QStringList() << ".test0.txt" << "test1.txt");
}
void TestJlCompress::compressDir()
{
QFETCH(QString, zipName);
QFETCH(QStringList, fileNames);
QFETCH(QList<int>, attributes);
QFETCH(QStringList, expected);
QDir curDir;
if (curDir.exists(zipName)) {
@ -128,7 +140,16 @@ void TestJlCompress::compressDir()
if (!createTestFiles(fileNames, "compressDir_tmp")) {
QFAIL("Can't create test files");
}
QVERIFY(JlCompress::compressDir(zipName, "compressDir_tmp"));
#ifdef Q_OS_WIN
for (int i = 0; i < attributes.size(); ++i) {
if ((attributes.at(i) & QDir::Hidden) != 0) {
QString fn = "compressDir_tmp\\" + fileNames.at(i);
SetFileAttributes(reinterpret_cast<LPCWSTR>(fn.utf16()),
FILE_ATTRIBUTE_HIDDEN);
}
}
#endif
QVERIFY(JlCompress::compressDir(zipName, "compressDir_tmp", true, QDir::Hidden));
// get the file list and check it
QStringList fileList = JlCompress::getFileList(zipName);
qSort(fileList);