Merge branch 'libraryincluded'

.gitattributes

+Zip/minizip/* linguist-vendored 
\ No newline at end of file

README.md

 ![Zip - Zip and unzip files in Swift](https://cloud.githubusercontent.com/assets/889949/12374908/252373d0-bcac-11e5-8ece-6933aeae8222.png)
 
 [![Build Status](https://travis-ci.org/marmelroy/Zip.svg?branch=master)](https://travis-ci.org/marmelroy/Zip) [![Version](http://img.shields.io/cocoapods/v/Zip.svg)](http://cocoapods.org/?q=Zip)
+[![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)
 
 # Zip
 A Swift framework for zipping and unzipping files. Simple and quick to use. Built on top of [minizip](https://github.com/nmoinvaz/minizip).
@@ -18,7 +19,7 @@ import Zip
 The easiest way to use Zip is through quick functions. Both take local file paths as NSURLs, throw if an error is encountered and return an NSURL to the destination if successful.
 ```swift
 do {
-    let filePath = NSBundle.mainBundle().URLForResource("file", withExtension: "zip")!
+    let filePath = Bundle.main.url(forResource: "file", withExtension: "zip")!
     let unzipDirectory = try Zip.quickUnzipFile(filePath) // Unzip
     let zipFilePath = try Zip.quickZipFiles([filePath], fileName: "archive") // Zip
 }
@@ -32,14 +33,13 @@ catch {
 For more advanced usage, Zip has functions that let you set custom  destination paths, work with password protected zips and use a progress handling closure. These functions throw if there is an error but don't return.
 ```swift
 do {
-    let filePath = NSBundle.mainBundle().URLForResource("file", withExtension: "zip")!
-    let documentsDirectory = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)[0] as NSURL
-
+    let filePath = Bundle.main.url(forResource: "file", withExtension: "zip")!
+    let documentsDirectory = FileManager.default.urls(for:.documentDirectory, in: .userDomainMask)[0]
     try Zip.unzipFile(filePath, destination: documentsDirectory, overwrite: true, password: "password", progress: { (progress) -> () in
         print(progress)
     }) // Unzip
 
-    let zipFilePath = documentsFolder.URLByAppendingPathComponent("archive.zip")
+    let zipFilePath = documentsFolder.appendingPathComponent("archive.zip")
     try Zip.zipFiles([filePath], zipFilePath: zipFilePath, password: "password", progress: { (progress) -> () in
         print(progress)
     }) //Zip
@@ -60,5 +60,22 @@ Zip.addCustomFileExtension("file-extension-here")
 ### Setting up with [CocoaPods](http://cocoapods.org/?q=Zip)
 ```ruby
 source 'https://github.com/CocoaPods/Specs.git'
-pod 'Zip', '~> 0.5', :submodules => true
+pod 'Zip', '~> 0.6'
+```
+
+### Setting up with Carthage
+
+[Carthage](https://github.com/Carthage/Carthage) is a decentralized dependency manager that automates the process of adding frameworks to your Cocoa application.
+
+You can install Carthage with [Homebrew](http://brew.sh/) using the following command:
+
+```bash
+$ brew update
+$ brew install carthage
+```
+
+To integrate Zip into your Xcode project using Carthage, specify it in your `Cartfile`:
+
+```ogdl
+github "marmelroy/Zip"
 ```

Zip.podspec

@@ -8,7 +8,7 @@
 
 Pod::Spec.new do |s|
   s.name             = "Zip"
-  s.version          = "0.5"
+  s.version          = "0.6"
   s.summary          = "Zip and unzip files in Swift."
 
 # This description is used to generate tags and improve search results.
@@ -24,7 +24,7 @@ Pod::Spec.new do |s|
   # s.screenshots     = "www.example.com/screenshots_1", "www.example.com/screenshots_2"
   s.license          = 'MIT'
   s.author           = { "Roy Marmelstein" => "marmelroy@gmail.com" }
-  s.source           = { :git => "https://github.com/marmelroy/Zip.git", :tag => s.version.to_s, :submodules => true}
+  s.source           = { :git => "https://github.com/marmelroy/Zip.git", :tag => s.version.to_s}
   s.social_media_url   = "http://twitter.com/marmelroy"
 
   s.ios.deployment_target = '8.0'

Zip/QuickZip.swift

@@ -89,7 +89,7 @@ extension Zip {
         let fileManager = FileManager.default
         let documentsUrl = fileManager.urls(for: .documentDirectory, in: .userDomainMask)[0] as URL
         let destinationUrl = documentsUrl.appendingPathComponent("\(fileName).zip")
-        try self.zipFiles(paths, zipFilePath: destinationUrl, password: nil, progress: progress)
+        try self.zipFiles(paths: paths, zipFilePath: destinationUrl, password: nil, progress: progress)
         return destinationUrl
     }
     

Zip/Zip.swift

@@ -28,6 +28,26 @@ public enum ZipError: Error {
     }
 }
 
+public enum ZipCompression: Int {
+    case NoCompression
+    case BestSpeed
+    case DefaultCompression
+    case BestCompression
+
+    internal var minizipCompression: Int32 {
+        switch self {
+        case .NoCompression:
+            return Z_NO_COMPRESSION
+        case .BestSpeed:
+            return Z_BEST_SPEED
+        case .DefaultCompression:
+            return Z_DEFAULT_COMPRESSION
+        case .BestCompression:
+            return Z_BEST_COMPRESSION
+        }
+    }
+}
+
 /// Zip class
 public class Zip {
     
@@ -197,19 +217,21 @@ public class Zip {
     
     // MARK: Zip
     
+    
     /**
      Zip files.
      
      - parameter paths:       Array of NSURL filepaths.
      - parameter zipFilePath: Destination NSURL, should lead to a .zip filepath.
      - parameter password:    Password string. Optional.
+     - parameter compression: Compression strategy
      - parameter progress: A progress closure called after unzipping each file in the archive. Double value betweem 0 and 1.
      
      - throws: Error if zipping fails.
      
      - notes: Supports implicit progress composition
      */
-    public class func zipFiles(_ paths: [URL], zipFilePath: URL, password: String?, progress: ((_ progress: Double) -> ())?) throws {
+    public class func zipFiles(paths: [URL], zipFilePath: URL, password: String?, compression: ZipCompression = .DefaultCompression, progress: ((_ progress: Double) -> ())?) throws {
         
         // File manager
         let fileManager = FileManager.default
@@ -275,10 +297,10 @@ public class Zip {
                 catch {}
                 let buffer = malloc(chunkSize)
                 if let password = password, let fileName = fileName {
-                    zipOpenNewFileInZip3(zip, fileName, &zipInfo, nil, 0, nil, 0, nil,Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, password, 0)
+                    zipOpenNewFileInZip3(zip, fileName, &zipInfo, nil, 0, nil, 0, nil,Z_DEFLATED, compression.minizipCompression, 0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, password, 0)
                 }
                 else if let fileName = fileName {
-                    zipOpenNewFileInZip3(zip, fileName, &zipInfo, nil, 0, nil, 0, nil,Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, nil, 0)
+                    zipOpenNewFileInZip3(zip, fileName, &zipInfo, nil, 0, nil, 0, nil,Z_DEFLATED, compression.minizipCompression, 0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, nil, 0)
                 }
                 else {
                     throw ZipError.zipFail

minizip @ 202b541f

-Subproject commit 202b541f5c6ec31e045d1d479601f2e7dd5f654c

Zip/minizip/crypt.h

+/* crypt.h -- base code for traditional PKWARE encryption
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+   Modifications for Info-ZIP crypting
+     Copyright (C) 2003 Terry Thorsen
+
+   This code is a modified version of crypting code in Info-ZIP distribution
+
+   Copyright (C) 1990-2000 Info-ZIP.  All rights reserved.
+
+   See the Info-ZIP LICENSE file version 2000-Apr-09 or later for terms of use
+   which also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
+
+   The encryption/decryption parts of this source code (as opposed to the
+   non-echoing password parts) were originally written in Europe. The
+   whole source package can be freely distributed, including from the USA.
+   (Prior to January 2000, re-export from the US was a violation of US law.)
+
+   This encryption code is a direct transcription of the algorithm from
+   Roger Schlafly, described by Phil Katz in the file appnote.txt. This
+   file (appnote.txt) is distributed with the PKZIP program (even in the
+   version without encryption capabilities).
+
+   If you don't need crypting in your application, just define symbols
+   NOCRYPT and NOUNCRYPT.
+*/
+
+#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
+
+/***********************************************************************
+ * Return the next byte in the pseudo-random sequence
+ */
+static int decrypt_byte(unsigned long* pkeys)
+{
+    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
+                     * unpredictable manner on 16-bit systems; not a problem
+                     * with any known compiler so far, though */
+
+    temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
+    return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
+}
+
+/***********************************************************************
+ * Update the encryption keys with the next byte of plain text
+ */
+static int update_keys(unsigned long* pkeys, const unsigned long* pcrc_32_tab, int c)
+{
+    (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
+    (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
+    (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
+    {
+        register int keyshift = (int)((*(pkeys+1)) >> 24);
+        (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
+    }
+    return c;
+}
+
+
+/***********************************************************************
+ * Initialize the encryption keys and the random header according to
+ * the given password.
+ */
+static void init_keys(const char* passwd, unsigned long* pkeys, const unsigned long* pcrc_32_tab)
+{
+    *(pkeys+0) = 305419896L;
+    *(pkeys+1) = 591751049L;
+    *(pkeys+2) = 878082192L;
+    while (*passwd != 0)
+    {
+        update_keys(pkeys,pcrc_32_tab,(int)*passwd);
+        passwd++;
+    }
+}
+
+#define zdecode(pkeys,pcrc_32_tab,c) \
+    (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys)))
+
+#define zencode(pkeys,pcrc_32_tab,c,t) \
+    (t=decrypt_byte(pkeys), update_keys(pkeys,pcrc_32_tab,c), t^(c))
+
+#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+
+#define RAND_HEAD_LEN  12
+   /* "last resort" source for second part of crypt seed pattern */
+#  ifndef ZCR_SEED2
+#    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
+#  endif
+
+static int crypthead(const char* passwd,      /* password string */
+                     unsigned char* buf,      /* where to write header */
+                     int bufSize,
+                     unsigned long* pkeys,
+                     const unsigned long* pcrc_32_tab,
+                     unsigned long crcForCrypting)
+{
+    int n;                                  /* index in random header */
+    int t;                                  /* temporary */
+    int c;                                  /* random byte */
+    unsigned char header[RAND_HEAD_LEN-2];  /* random header */
+    static unsigned calls = 0;              /* ensure different random header each time */
+
+    if (bufSize < RAND_HEAD_LEN)
+        return 0;
+
+    /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
+     * output of rand() to get less predictability, since rand() is
+     * often poorly implemented.
+     */
+    if (++calls == 1)
+    {
+        srand((unsigned)(time(NULL) ^ ZCR_SEED2));
+    }
+    init_keys(passwd, pkeys, pcrc_32_tab);
+    for (n = 0; n < RAND_HEAD_LEN-2; n++)
+    {
+        c = (rand() >> 7) & 0xff;
+        header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
+    }
+    /* Encrypt random header (last two bytes is high word of crc) */
+    init_keys(passwd, pkeys, pcrc_32_tab);
+    for (n = 0; n < RAND_HEAD_LEN-2; n++)
+    {
+        buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
+    }
+    buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
+    buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
+    return n;
+}
+
+#endif

Zip/minizip/ioapi.h

+/* ioapi.h -- IO base function header for compress/uncompress .zip
+   part of the MiniZip project
+
+   Copyright (C) 1998-2010 Gilles Vollant
+     http://www.winimage.com/zLibDll/minizip.html
+   Modifications for Zip64 support
+     Copyright (C) 2009-2010 Mathias Svensson
+     http://result42.com
+
+   This program is distributed under the terms of the same license as zlib.
+   See the accompanying LICENSE file for the full text of the license.
+*/
+
+#ifndef _ZLIBIOAPI64_H
+#define _ZLIBIOAPI64_H
+
+#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
+#  ifndef __USE_FILE_OFFSET64
+#    define __USE_FILE_OFFSET64
+#  endif
+#  ifndef __USE_LARGEFILE64
+#    define __USE_LARGEFILE64
+#  endif
+#  ifndef _LARGEFILE64_SOURCE
+#    define _LARGEFILE64_SOURCE
+#  endif
+#  ifndef _FILE_OFFSET_BIT
+#    define _FILE_OFFSET_BIT 64
+#  endif
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "zlib.h"
+
+#if defined(USE_FILE32API)
+#  define fopen64 fopen
+#  define ftello64 ftell
+#  define fseeko64 fseek
+#else
+#  if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
+#    define fopen64 fopen
+#    define ftello64 ftello
+#    define fseeko64 fseeko
+#  endif
+#  ifdef _MSC_VER
+#    define fopen64 fopen
+#    if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
+#      define ftello64 _ftelli64
+#      define fseeko64 _fseeki64
+#    else /* old MSC */
+#      define ftello64 ftell
+#      define fseeko64 fseek
+#    endif
+#  endif
+#endif
+
+/* a type choosen by DEFINE */
+#ifdef HAVE_64BIT_INT_CUSTOM
+typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T;
+#else
+#  ifdef HAVE_STDINT_H
+#    include "stdint.h"
+     typedef uint64_t ZPOS64_T;
+#  else
+#    if defined(_MSC_VER) || defined(__BORLANDC__)
+       typedef unsigned __int64 ZPOS64_T;
+#    else
+       typedef unsigned long long int ZPOS64_T;
+#    endif
+#  endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_FILEFUNC_SEEK_CUR (1)
+#define ZLIB_FILEFUNC_SEEK_END (2)
+#define ZLIB_FILEFUNC_SEEK_SET (0)
+
+#define ZLIB_FILEFUNC_MODE_READ             (1)
+#define ZLIB_FILEFUNC_MODE_WRITE            (2)
+#define ZLIB_FILEFUNC_MODE_READWRITEFILTER  (3)
+#define ZLIB_FILEFUNC_MODE_EXISTING         (4)
+#define ZLIB_FILEFUNC_MODE_CREATE           (8)
+
+#ifndef ZCALLBACK
+#  if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || \
+       defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
+#    define ZCALLBACK CALLBACK
+#  else
+#    define ZCALLBACK
+#  endif
+#endif
+
+typedef voidpf   (ZCALLBACK *open_file_func)      OF((voidpf opaque, const char* filename, int mode));
+typedef voidpf   (ZCALLBACK *opendisk_file_func)  OF((voidpf opaque, voidpf stream, int number_disk, int mode));
+typedef uLong    (ZCALLBACK *read_file_func)      OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+typedef uLong    (ZCALLBACK *write_file_func)     OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
+typedef int      (ZCALLBACK *close_file_func)     OF((voidpf opaque, voidpf stream));
+typedef int      (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
+
+typedef long     (ZCALLBACK *tell_file_func)      OF((voidpf opaque, voidpf stream));
+typedef long     (ZCALLBACK *seek_file_func)      OF((voidpf opaque, voidpf stream, uLong offset, int origin));
+
+/* here is the "old" 32 bits structure structure */
+typedef struct zlib_filefunc_def_s
+{
+    open_file_func      zopen_file;
+    opendisk_file_func  zopendisk_file;
+    read_file_func      zread_file;
+    write_file_func     zwrite_file;
+    tell_file_func      ztell_file;
+    seek_file_func      zseek_file;
+    close_file_func     zclose_file;
+    testerror_file_func zerror_file;
+    voidpf              opaque;
+} zlib_filefunc_def;
+
+typedef ZPOS64_T (ZCALLBACK *tell64_file_func)    OF((voidpf opaque, voidpf stream));
+typedef long     (ZCALLBACK *seek64_file_func)    OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+typedef voidpf   (ZCALLBACK *open64_file_func)    OF((voidpf opaque, const void* filename, int mode));
+typedef voidpf   (ZCALLBACK *opendisk64_file_func)OF((voidpf opaque, voidpf stream, int number_disk, int mode));
+
+typedef struct zlib_filefunc64_def_s
+{
+    open64_file_func     zopen64_file;
+    opendisk64_file_func zopendisk64_file;
+    read_file_func       zread_file;
+    write_file_func      zwrite_file;
+    tell64_file_func     ztell64_file;
+    seek64_file_func     zseek64_file;
+    close_file_func      zclose_file;
+    testerror_file_func  zerror_file;
+    voidpf               opaque;
+} zlib_filefunc64_def;
+
+void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def));
+
+/* now internal definition, only for zip.c and unzip.h */
+typedef struct zlib_filefunc64_32_def_s
+{
+    zlib_filefunc64_def zfile_func64;
+    open_file_func      zopen32_file;
+    opendisk_file_func  zopendisk32_file;
+    tell_file_func      ztell32_file;
+    seek_file_func      zseek32_file;
+} zlib_filefunc64_32_def;
+
+#define ZREAD64(filefunc,filestream,buf,size)       ((*((filefunc).zfile_func64.zread_file))        ((filefunc).zfile_func64.opaque,filestream,buf,size))
+#define ZWRITE64(filefunc,filestream,buf,size)      ((*((filefunc).zfile_func64.zwrite_file))       ((filefunc).zfile_func64.opaque,filestream,buf,size))
+/*#define ZTELL64(filefunc,filestream)                ((*((filefunc).ztell64_file))                   ((filefunc).opaque,filestream))*/
+/*#define ZSEEK64(filefunc,filestream,pos,mode)       ((*((filefunc).zseek64_file))                   ((filefunc).opaque,filestream,pos,mode))*/
+#define ZCLOSE64(filefunc,filestream)               ((*((filefunc).zfile_func64.zclose_file))       ((filefunc).zfile_func64.opaque,filestream))
+#define ZERROR64(filefunc,filestream)               ((*((filefunc).zfile_func64.zerror_file))       ((filefunc).zfile_func64.opaque,filestream))
+
+voidpf   call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode));
+voidpf   call_zopendisk64 OF((const zlib_filefunc64_32_def* pfilefunc, voidpf filestream, int number_disk, int mode));
+long     call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin));
+ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream));
+
+void fill_zlib_filefunc64_32_def_from_filefunc32 OF((zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32));
+
+#define ZOPEN64(filefunc,filename,mode)             (call_zopen64((&(filefunc)),(filename),(mode)))
+#define ZOPENDISK64(filefunc,filestream,diskn,mode) (call_zopendisk64((&(filefunc)),(filestream),(diskn),(mode)))
+#define ZTELL64(filefunc,filestream)                (call_ztell64((&(filefunc)),(filestream)))
+#define ZSEEK64(filefunc,filestream,pos,mode)       (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Zip/minizip/module.modulemap

+module minizip [system][extern_c] {
+    header "unzip.h"
+    header "zip.h"
+    export *
+}

Zip/minizip/zip.h

+/* zip.h -- IO on .zip files using zlib
+   Version 1.1, February 14h, 2010
+   part of the MiniZip project
+
+   Copyright (C) 1998-2010 Gilles Vollant
+     http://www.winimage.com/zLibDll/minizip.html
+   Modifications for Zip64 support
+     Copyright (C) 2009-2010 Mathias Svensson
+     http://result42.com
+
+   This program is distributed under the terms of the same license as zlib.
+   See the accompanying LICENSE file for the full text of the license.
+*/
+
+#ifndef _ZIP_H
+#define _ZIP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _ZLIB_H
+#  include "zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#  include "ioapi.h"
+#endif
+
+#ifdef HAVE_BZIP2
+#  include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
+#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+typedef struct TagzipFile__ { int unused; } zipFile__;
+typedef zipFile__ *zipFile;
+#else
+typedef voidp zipFile;
+#endif
+
+#define ZIP_OK                          (0)
+#define ZIP_EOF                         (0)
+#define ZIP_ERRNO                       (Z_ERRNO)
+#define ZIP_PARAMERROR                  (-102)
+#define ZIP_BADZIPFILE                  (-103)
+#define ZIP_INTERNALERROR               (-104)
+
+#ifndef DEF_MEM_LEVEL
+#  if MAX_MEM_LEVEL >= 8
+#    define DEF_MEM_LEVEL 8
+#  else
+#    define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#  endif
+#endif
+/* default memLevel */
+
+/* tm_zip contain date/time info */
+typedef struct tm_zip_s
+{
+    uInt tm_sec;                /* seconds after the minute - [0,59] */
+    uInt tm_min;                /* minutes after the hour - [0,59] */
+    uInt tm_hour;               /* hours since midnight - [0,23] */
+    uInt tm_mday;               /* day of the month - [1,31] */
+    uInt tm_mon;                /* months since January - [0,11] */
+    uInt tm_year;               /* years - [1980..2044] */
+} tm_zip;
+
+typedef struct
+{
+    tm_zip      tmz_date;       /* date in understandable format           */
+    uLong       dosDate;        /* if dos_date == 0, tmu_date is used      */
+    uLong       internal_fa;    /* internal file attributes        2 bytes */
+    uLong       external_fa;    /* external file attributes        4 bytes */
+} zip_fileinfo;
+
+#define APPEND_STATUS_CREATE        (0)
+#define APPEND_STATUS_CREATEAFTER   (1)
+#define APPEND_STATUS_ADDINZIP      (2)
+
+/***************************************************************************/
+/* Writing a zip file */
+
+extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
+extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));
+/* Create a zipfile.
+
+   pathname should contain the full pathname (by example, on a Windows XP computer 
+      "c:\\zlib\\zlib113.zip" or on an Unix computer "zlib/zlib113.zip". 
+
+   return NULL if zipfile cannot be opened
+   return zipFile handle if no error
+
+   If the file pathname exist and append == APPEND_STATUS_CREATEAFTER, the zip
+   will be created at the end of the file. (useful if the file contain a self extractor code)
+   If the file pathname exist and append == APPEND_STATUS_ADDINZIP, we will add files in existing 
+   zip (be sure you don't add file that doesn't exist)
+
+   NOTE: There is no delete function into a zipfile. If you want delete file into a zipfile, 
+   you must open a zipfile, and create another. Of course, you can use RAW reading and writing to copy
+   the file you did not want delete. */
+
+extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, int append, const char ** globalcomment, 
+    zlib_filefunc_def* pzlib_filefunc_def));
+
+extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname, int append, const char ** globalcomment, 
+    zlib_filefunc64_def* pzlib_filefunc_def));
+
+extern zipFile ZEXPORT zipOpen3 OF((const char *pathname, int append, ZPOS64_T disk_size, 
+    const char ** globalcomment, zlib_filefunc_def* pzlib_filefunc_def));
+/* Same as zipOpen2 but allows specification of spanned zip size */
+
+extern zipFile ZEXPORT zipOpen3_64 OF((const void *pathname, int append, ZPOS64_T disk_size, 
+    const char ** globalcomment, zlib_filefunc64_def* pzlib_filefunc_def));
+
+extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,
+    const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, 
+    uInt size_extrafield_global, const char* comment, int method, int level));
+/* Open a file in the ZIP for writing.
+
+   filename : the filename in zip (if NULL, '-' without quote will be used
+   *zipfi contain supplemental information
+   extrafield_local buffer to store the local header extra field data, can be NULL
+   size_extrafield_local size of extrafield_local buffer
+   extrafield_global buffer to store the global header extra field data, can be NULL
+   size_extrafield_global size of extrafield_local buffer
+   comment buffer for comment string
+   method contain the compression method (0 for store, Z_DEFLATED for deflate)
+   level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
+   zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
+   this MUST be '1' if the uncompressed size is >= 0xffffffff. */
+
+extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,
+    const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, 
+    uInt size_extrafield_global, const char* comment, int method, int level, int zip64));
+/* Same as zipOpenNewFileInZip with zip64 support */
+
+extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,
+    const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, 
+    uInt size_extrafield_global, const char* comment, int method, int level, int raw));
+/* Same as zipOpenNewFileInZip, except if raw=1, we write raw file */
+
+extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,
+    const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, 
+    uInt size_extrafield_global, const char* comment, int method, int level, int raw, int zip64));
+/* Same as zipOpenNewFileInZip3 with zip64 support */
+
+extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,
+    const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, 
+    uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, 
+    int strategy, const char* password, uLong crcForCrypting));
+/* Same as zipOpenNewFileInZip2, except
+    windowBits, memLevel, strategy : see parameter strategy in deflateInit2
+    password : crypting password (NULL for no crypting)
+    crcForCrypting : crc of file to compress (needed for crypting) */
+
+extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,
+    const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, 
+    uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, 
+    int strategy, const char* password, uLong crcForCrypting, int zip64));
+/* Same as zipOpenNewFileInZip3 with zip64 support */
+
+extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,
+    const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, 
+    uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, 
+    int strategy, const char* password, uLong crcForCrypting, uLong versionMadeBy, uLong flagBase));
+/* Same as zipOpenNewFileInZip3 except versionMadeBy & flag fields */
+
+extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,
+    const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, 
+    uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, 
+    int strategy, const char* password, uLong crcForCrypting, uLong versionMadeBy, uLong flagBase, int zip64));
+/* Same as zipOpenNewFileInZip4 with zip64 support */
+
+extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, const void* buf, unsigned len));
+/* Write data in the zipfile */
+
+extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
+/* Close the current file in the zipfile */
+
+extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, uLong uncompressed_size, uLong crc32));
+extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file, ZPOS64_T uncompressed_size, uLong crc32));
+/* Close the current file in the zipfile, for file opened with parameter raw=1 in zipOpenNewFileInZip2
+   uncompressed_size and crc32 are value for the uncompressed size */
+
+extern int ZEXPORT zipClose OF((zipFile file, const char* global_comment));
+/* Close the zipfile */
+
+/***************************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ZIP_H */

ZipTests/ZipTests.swift

@@ -128,7 +128,7 @@ class ZipTests: XCTestCase {
             let zipFilePath = documentsFolder.appendingPathComponent("archive.zip")
             
             progress.becomeCurrent(withPendingUnitCount: 1)
-            try Zip.zipFiles([imageURL1, imageURL2], zipFilePath: zipFilePath!, password: nil, progress: nil)
+            try Zip.zipFiles(paths: [imageURL1, imageURL2], zipFilePath: zipFilePath!, password: nil, progress: nil)
             progress.resignCurrent()
             
             XCTAssertTrue(progress.totalUnitCount == progress.completedUnitCount)
@@ -181,7 +181,7 @@ class ZipTests: XCTestCase {
             let imageURL2 = Bundle(for: ZipTests.self).url(forResource: "kYkLkPf", withExtension: "gif")!
             let documentsFolder = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0] as NSURL
             let zipFilePath = documentsFolder.appendingPathComponent("archive.zip")
-            try Zip.zipFiles([imageURL1, imageURL2], zipFilePath: zipFilePath!, password: nil, progress: { (progress) -> () in
+            try Zip.zipFiles(paths: [imageURL1, imageURL2], zipFilePath: zipFilePath!, password: nil, progress: { (progress) -> () in
                 print(progress)
             })
             let fileManager = FileManager.default
@@ -198,7 +198,7 @@ class ZipTests: XCTestCase {
             let imageURL2 = Bundle(for: ZipTests.self).url(forResource: "kYkLkPf", withExtension: "gif")!
             let documentsFolder = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0] as NSURL
             let zipFilePath = documentsFolder.appendingPathComponent("archive.zip")
-            try Zip.zipFiles([imageURL1, imageURL2], zipFilePath: zipFilePath!, password: "password", progress: { (progress) -> () in
+            try Zip.zipFiles(paths: [imageURL1, imageURL2], zipFilePath: zipFilePath!, password: "password", progress: { (progress) -> () in
                 print(progress)
             })
             let fileManager = FileManager.default