patch

5 files changed, 773 insertions, 32 deletions

diff --git a/src/luarocks/core/cfg.d.tl b/src/luarocks/core/cfg.d.tl
index 5ad95b6d..7b74f258 100644
--- a/src/luarocks/core/cfg.d.tl
+++ b/src/luarocks/core/cfg.d.tl
@@ -86,6 +86,8 @@ local record cfg
    record upload
       server: string
       version: string
+      tool_version: string
+      api_version: string
    end
 end
 
diff --git a/src/luarocks/tools/patch.tl b/src/luarocks/tools/patch.tl
index a3dbe0df..05b447da 100644
--- a/src/luarocks/tools/patch.tl
+++ b/src/luarocks/tools/patch.tl
@@ -9,17 +9,32 @@
 --   Version 0.1
 
 local record patch
-
+  record Lineends
+    lf: number
+    crlf: number
+    cr: number
+  end
+  record Hunks
+    startsrc: number
+    linessrc: number
+    starttgt: number
+    linestgt: number
+    invalid: boolean
+    text: {string}
+  end
 end
 
 local fs = require("luarocks.fs")
 local fun = require("luarocks.fun")
 
-local io = io
-local os = os
-local string = string
-local table = table
-local format = string.format
+local type Lineends = patch.Lineends
+local type Hunks = patch.Hunks
+
+-- local io = io
+-- local os = os
+-- local string = string
+-- local table = table
+-- local format = string.format
 
 -- logging
 local debugmode = false
@@ -38,7 +53,7 @@ local function endswith(s: string, s2: string): boolean
 end
 
 -- Returns string s after filtering out any new-line characters from end.
-local function endlstrip(s: string): string
+local function endlstrip(s: string): string, integer
   return s:gsub('[\r\n]+$', '')
 end
 
@@ -57,13 +72,13 @@ local function exists(filename: string): boolean
 end
 local function isfile(): boolean return true end --FIX? --!
 
-local function string_as_file(s: string) --!
+local function string_as_file(s: string): FILE --!
    return {
       at = 0,
       str = s,
       len = #s,
       eof = false,
-      read = function(self, n)
+      read = function(self: FILE, n: number): string
          if self.eof then return nil end
          local chunk = self.str:sub(self.at, self.at + n - 1)
          self.at = self.at + n
@@ -72,10 +87,10 @@ local function string_as_file(s: string) --!
          end
          return chunk
       end,
-      close = function(self)
+      close = function(self: FILE): boolean
          self.eof = true
       end,
-   }
+   } as FILE
 end
 
 --
@@ -92,7 +107,7 @@ local function file_lines(f: FILE): function(): string
   local buffer = ""
   local pos_beg = 1
   return function(): string
-    local pos, chars: number, number --? char represented as a number
+    local pos, chars: string, string
     while 1 do
       pos, chars = buffer:match('()([\r\n].)', pos_beg)
       if pos or not f then
@@ -100,27 +115,28 @@ local function file_lines(f: FILE): function(): string
       elseif f then
         local chunk = f:read(CHUNK_SIZE)
         if chunk then
-          buffer = buffer:sub(pos_beg) .. chunk
+          buffer = buffer:sub(pos_beg) .. chunk           --! funcy stuff with pos
           pos_beg = 1
         else
           f = nil
         end
       end
     end
-    if not pos then
-      pos = #buffer
+    local posi = math.tointeger(pos)
+    if not posi then
+      posi = #buffer
     elseif chars == '\r\n' then
-      pos = pos + 1
+      posi = posi + 1
     end
-    local line = buffer:sub(pos_beg, pos)
-    pos_beg = pos + 1
+    local line = buffer:sub(pos_beg, posi)
+    pos_beg = posi + 1
     if #line > 0 then
       return line
     end
   end
 end
 
-local function match_linerange(line: string)
+local function match_linerange(line: string): string, string, string, string
   local m1, m2, m3, m4 =      line:match("^@@ %-(%d+),(%d+) %+(%d+),(%d+)")
   if not m1 then m1, m3, m4 = line:match("^@@ %-(%d+) %+(%d+),(%d+)") end
   if not m1 then m1, m2, m3 = line:match("^@@ %-(%d+),(%d+) %+(%d+)") end
@@ -128,11 +144,11 @@ local function match_linerange(line: string)
   return m1, m2, m3, m4
 end
 
-local function match_epoch(str)
+local function match_epoch(str: string): string
   return str:match("[^0-9]1969[^0-9]") or str:match("[^0-9]1970[^0-9]")
 end
 
-function patch.read_patch(filename, data)
+function patch.read_patch(filename: string, data: string)
   -- define possible file regions that will direct the parser flow
   local state = 'header'
     -- 'header'    - comments before the patch body
@@ -142,26 +158,26 @@ function patch.read_patch(filename, data)
     -- 'hunkskip'  - skipping invalid hunk mode
 
   local all_ok = true
-  local lineends = {lf=0, crlf=0, cr=0}
-  local files = {source={}, target={}, epoch={}, hunks={}, fileends={}, hunkends={}}
+  local lineends: Lineends = {lf=0, crlf=0, cr=0}
+  local files = {source={}, target={}, epoch={}, hunks: {{Hunks}}={}, fileends={}, hunkends: {Lineends}={}}
   local nextfileno = 0
   local nexthunkno = 0    --: even if index starts with 0 user messages
                           --  number hunks from 1
 
   -- hunkinfo holds parsed values, hunkactual - calculated
-  local hunkinfo = {
+  local hunkinfo: Hunks = {
     startsrc=nil, linessrc=nil, starttgt=nil, linestgt=nil,
     invalid=false, text={}
   }
-  local hunkactual = {linessrc=nil, linestgt=nil}
+  local hunkactual: Hunks = {linessrc=nil, linestgt=nil}
 
-  info(format("reading patch %s", filename))
+  info(string.format("reading patch %s", filename)) --!
 
-  local fp
+  local fp: FILE
   if data then
     fp = string_as_file(data)
   else
-    fp = filename == '-' and io.stdin or assert(io.open(filename, "rb"))
+    fp = filename == '-' and io.stdin or assert(io.open(filename, "rb") as (FILE, string)) --! use of cast
   end
   local lineno = 0
 
@@ -205,10 +221,10 @@ function patch.read_patch(filename, data)
           table.insert(hunkinfo.text, line)
           -- todo: handle \ No newline cases
       else
-          warning(format("invalid hunk no.%d at %d for target file %s",
+          warning(string.format("invalid hunk no.%d at %d for target file %s",
                          nexthunkno, lineno, files.target[nextfileno]))
           -- add hunk status node
-          table.insert(files.hunks[nextfileno], table_copy(hunkinfo))
+          table.insert(files.hunks[nextfileno], table_copy(hunkinfo)) --! cast
           files.hunks[nextfileno][nexthunkno].invalid = true
           all_ok = false
           state = 'hunkskip'
@@ -218,7 +234,7 @@ function patch.read_patch(filename, data)
       if hunkactual.linessrc > hunkinfo.linessrc or
          hunkactual.linestgt > hunkinfo.linestgt
       then
-          warning(format("extra hunk no.%d lines at %d for target %s",
+          warning(string.format("extra hunk no.%d lines at %d for target %s",
                          nexthunkno, lineno, files.target[nextfileno]))
           -- add hunk status node
           table.insert(files.hunks[nextfileno], table_copy(hunkinfo))
@@ -235,7 +251,7 @@ function patch.read_patch(filename, data)
           if (ends.cr~=0 and 1 or 0) + (ends.crlf~=0 and 1 or 0) +
              (ends.lf~=0 and 1 or 0) > 1
           then
-            warning(format("inconsistent line ends in patch hunks for %s",
+            warning(string.format("inconsistent line ends in patch hunks for %s",
                     files.source[nextfileno]))
           end
       end
diff --git a/src/luarocks/tools/tar.tl b/src/luarocks/tools/tar.tl
new file mode 100644
index 00000000..bac7b2a9
--- /dev/null
+++ b/src/luarocks/tools/tar.tl
@@ -0,0 +1,191 @@
+
+--- A pure-Lua implementation of untar (unpacking .tar archives)
+local tar = {}
+
+local fs = require("luarocks.fs")
+local dir = require("luarocks.dir")
+local fun = require("luarocks.fun")
+
+local blocksize = 512
+
+local function get_typeflag(flag)
+   if flag == "0" or flag == "\0" then return "file"
+   elseif flag == "1" then return "link"
+   elseif flag == "2" then return "symlink" -- "reserved" in POSIX, "symlink" in GNU
+   elseif flag == "3" then return "character"
+   elseif flag == "4" then return "block"
+   elseif flag == "5" then return "directory"
+   elseif flag == "6" then return "fifo"
+   elseif flag == "7" then return "contiguous" -- "reserved" in POSIX, "contiguous" in GNU
+   elseif flag == "x" then return "next file"
+   elseif flag == "g" then return "global extended header"
+   elseif flag == "L" then return "long name"
+   elseif flag == "K" then return "long link name"
+   end
+   return "unknown"
+end
+
+local function octal_to_number(octal)
+   local exp = 0
+   local number = 0
+   octal = octal:gsub("%s", "")
+   for i = #octal,1,-1 do
+      local digit = tonumber(octal:sub(i,i))
+      if not digit then
+         break
+      end
+      number = number + (digit * 8^exp)
+      exp = exp + 1
+   end
+   return number
+end
+
+local function checksum_header(block)
+   local sum = 256
+
+   if block:byte(1) == 0 then
+      return 0
+   end
+
+   for i = 1,148 do
+      local b = block:byte(i) or 0
+      sum = sum + b
+   end
+   for i = 157,500 do
+      local b = block:byte(i) or 0
+      sum = sum + b
+   end
+
+   return sum
+end
+
+local function nullterm(s)
+   return s:match("^[^%z]*")
+end
+
+local function read_header_block(block)
+   local header = {}
+   header.name = nullterm(block:sub(1,100))
+   header.mode = nullterm(block:sub(101,108)):gsub(" ", "")
+   header.uid = octal_to_number(nullterm(block:sub(109,116)))
+   header.gid = octal_to_number(nullterm(block:sub(117,124)))
+   header.size = octal_to_number(nullterm(block:sub(125,136)))
+   header.mtime = octal_to_number(nullterm(block:sub(137,148)))
+   header.chksum = octal_to_number(nullterm(block:sub(149,156)))
+   header.typeflag = get_typeflag(block:sub(157,157))
+   header.linkname = nullterm(block:sub(158,257))
+   header.magic = block:sub(258,263)
+   header.version = block:sub(264,265)
+   header.uname = nullterm(block:sub(266,297))
+   header.gname = nullterm(block:sub(298,329))
+   header.devmajor = octal_to_number(nullterm(block:sub(330,337)))
+   header.devminor = octal_to_number(nullterm(block:sub(338,345)))
+   header.prefix = block:sub(346,500)
+
+   -- if header.magic ~= "ustar " and header.magic ~= "ustar\0" then
+   --    return false, ("Invalid header magic %6x"):format(bestring_to_number(header.magic))
+   -- end
+   -- if header.version ~= "00" and header.version ~= " \0" then
+   --    return false, "Unknown version "..header.version
+   -- end
+   if header.typeflag == "unknown" then
+      if checksum_header(block) ~= header.chksum then
+         return false, "Failed header checksum"
+      end
+   end
+   return header
+end
+
+function tar.untar(filename, destdir)
+   assert(type(filename) == "string")
+   assert(type(destdir) == "string")
+
+   local tar_handle = io.open(filename, "rb")
+   if not tar_handle then return nil, "Error opening file "..filename end
+
+   local long_name, long_link_name
+   local ok, err
+   local make_dir = fun.memoize(fs.make_dir)
+   while true do
+      local block
+      repeat
+         block = tar_handle:read(blocksize)
+      until (not block) or block:byte(1) > 0
+      if not block then break end
+      if #block < blocksize then
+         ok, err = nil, "Invalid block size -- corrupted file?"
+         break
+      end
+
+      local header
+      header, err = read_header_block(block)
+      if not header then
+         ok = false
+         break
+      end
+
+      local file_data = ""
+      if header.size > 0 then
+         local nread = math.ceil(header.size / blocksize) * blocksize
+         file_data = tar_handle:read(header.size)
+         if nread > header.size then
+            tar_handle:seek("cur", nread - header.size)
+         end
+      end
+
+      if header.typeflag == "long name" then
+         long_name = nullterm(file_data)
+      elseif header.typeflag == "long link name" then
+         long_link_name = nullterm(file_data)
+      else
+         if long_name then
+            header.name = long_name
+            long_name = nil
+         end
+         if long_link_name then
+            header.name = long_link_name
+            long_link_name = nil
+         end
+      end
+      local pathname = dir.path(destdir, header.name)
+      pathname = fs.absolute_name(pathname)
+      if header.typeflag == "directory" then
+         ok, err = make_dir(pathname)
+         if not ok then
+            break
+         end
+      elseif header.typeflag == "file" then
+         local dirname = dir.dir_name(pathname)
+         if dirname ~= "" then
+            ok, err = make_dir(dirname)
+            if not ok then
+               break
+            end
+         end
+         local file_handle
+         file_handle, err = io.open(pathname, "wb")
+         if not file_handle then
+            ok = nil
+            break
+         end
+         file_handle:write(file_data)
+         file_handle:close()
+         fs.set_time(pathname, header.mtime)
+         if header.mode:match("[75]") then
+            fs.set_permissions(pathname, "exec", "all")
+         else
+            fs.set_permissions(pathname, "read", "all")
+         end
+      end
+      --[[
+      for k,v in pairs(header) do
+         util.printout("[\""..tostring(k).."\"] = "..(type(v)=="number" and v or "\""..v:gsub("%z", "\\0").."\""))
+      end
+      util.printout()
+      --]]
+   end
+   tar_handle:close()
+   return ok, err
+end
+
+return tar
diff --git a/src/luarocks/tools/zip.tl b/src/luarocks/tools/zip.tl
new file mode 100644
index 00000000..82d582fa
--- /dev/null
+++ b/src/luarocks/tools/zip.tl
@@ -0,0 +1,531 @@
+
+--- A Lua implementation of .zip and .gz file compression and decompression,
+-- using only lzlib or lua-lzib.
+local zip = {}
+
+local zlib = require("zlib")
+local fs = require("luarocks.fs")
+local fun = require("luarocks.fun")
+local dir = require("luarocks.dir")
+
+local pack = table.pack or function(...) return { n = select("#", ...), ... } end
+
+local function shr(n, m)
+   return math.floor(n / 2^m)
+end
+
+local function shl(n, m)
+   return n * 2^m
+end
+local function lowbits(n, m)
+   return n % 2^m
+end
+
+local function mode_to_windowbits(mode)
+   if mode == "gzip" then
+      return 31
+   elseif mode == "zlib" then
+      return 0
+   elseif mode == "raw" then
+      return -15
+   end
+end
+
+-- zlib module can be provided by both lzlib and lua-lzib packages.
+-- Create a compatibility layer.
+local zlib_compress, zlib_uncompress, zlib_crc32
+if zlib._VERSION:match "^lua%-zlib" then
+   function zlib_compress(data, mode)
+      return (zlib.deflate(6, mode_to_windowbits(mode))(data, "finish"))
+   end
+
+   function zlib_uncompress(data, mode)
+      return (zlib.inflate(mode_to_windowbits(mode))(data))
+   end
+
+   function zlib_crc32(data)
+      return zlib.crc32()(data)
+   end
+elseif zlib._VERSION:match "^lzlib" then
+   function zlib_compress(data, mode)
+      return zlib.compress(data, -1, nil, mode_to_windowbits(mode))
+   end
+
+   function zlib_uncompress(data, mode)
+      return zlib.decompress(data, mode_to_windowbits(mode))
+   end
+
+   function zlib_crc32(data)
+      return zlib.crc32(zlib.crc32(), data)
+   end
+else
+   error("unknown zlib library", 0)
+end
+
+local function number_to_lestring(number, nbytes)
+   local out = {}
+   for _ = 1, nbytes do
+      local byte = number % 256
+      table.insert(out, string.char(byte))
+      number = (number - byte) / 256
+   end
+   return table.concat(out)
+end
+
+local function lestring_to_number(str)
+   local n = 0
+   local bytes = { string.byte(str, 1, #str) }
+   for b = 1, #str do
+      n = n + shl(bytes[b], (b-1)*8)
+   end
+   return math.floor(n)
+end
+
+local LOCAL_FILE_HEADER_SIGNATURE  = number_to_lestring(0x04034b50, 4)
+local DATA_DESCRIPTOR_SIGNATURE    = number_to_lestring(0x08074b50, 4)
+local CENTRAL_DIRECTORY_SIGNATURE  = number_to_lestring(0x02014b50, 4)
+local END_OF_CENTRAL_DIR_SIGNATURE = number_to_lestring(0x06054b50, 4)
+
+--- Begin a new file to be stored inside the zipfile.
+-- @param self handle of the zipfile being written.
+-- @param filename filenome of the file to be added to the zipfile.
+-- @return true if succeeded, nil in case of failure.
+local function zipwriter_open_new_file_in_zip(self, filename)
+   if self.in_open_file then
+      self:close_file_in_zip()
+      return nil
+   end
+   local lfh = {}
+   self.local_file_header = lfh
+   lfh.last_mod_file_time = 0 -- TODO
+   lfh.last_mod_file_date = 0 -- TODO
+   lfh.file_name_length = #filename
+   lfh.extra_field_length = 0
+   lfh.file_name = filename:gsub("\\", "/")
+   lfh.external_attr = shl(493, 16) -- TODO proper permissions
+   self.in_open_file = true
+   return true
+end
+
+--- Write data to the file currently being stored in the zipfile.
+-- @param self handle of the zipfile being written.
+-- @param data string containing full contents of the file.
+-- @return true if succeeded, nil in case of failure.
+local function zipwriter_write_file_in_zip(self, data)
+   if not self.in_open_file then
+      return nil
+   end
+   local lfh = self.local_file_header
+   local compressed = zlib_compress(data, "raw")
+   lfh.crc32 = zlib_crc32(data)
+   lfh.compressed_size = #compressed
+   lfh.uncompressed_size = #data
+   self.data = compressed
+   return true
+end
+
+--- Complete the writing of a file stored in the zipfile.
+-- @param self handle of the zipfile being written.
+-- @return true if succeeded, nil in case of failure.
+local function zipwriter_close_file_in_zip(self)
+   local zh = self.ziphandle
+
+   if not self.in_open_file then
+      return nil
+   end
+
+   -- Local file header
+   local lfh = self.local_file_header
+   lfh.offset = zh:seek()
+   zh:write(LOCAL_FILE_HEADER_SIGNATURE)
+   zh:write(number_to_lestring(20, 2)) -- version needed to extract: 2.0
+   zh:write(number_to_lestring(4, 2)) -- general purpose bit flag
+   zh:write(number_to_lestring(8, 2)) -- compression method: deflate
+   zh:write(number_to_lestring(lfh.last_mod_file_time, 2))
+   zh:write(number_to_lestring(lfh.last_mod_file_date, 2))
+   zh:write(number_to_lestring(lfh.crc32, 4))
+   zh:write(number_to_lestring(lfh.compressed_size, 4))
+   zh:write(number_to_lestring(lfh.uncompressed_size, 4))
+   zh:write(number_to_lestring(lfh.file_name_length, 2))
+   zh:write(number_to_lestring(lfh.extra_field_length, 2))
+   zh:write(lfh.file_name)
+
+   -- File data
+   zh:write(self.data)
+
+   -- Data descriptor
+   zh:write(DATA_DESCRIPTOR_SIGNATURE)
+   zh:write(number_to_lestring(lfh.crc32, 4))
+   zh:write(number_to_lestring(lfh.compressed_size, 4))
+   zh:write(number_to_lestring(lfh.uncompressed_size, 4))
+
+   table.insert(self.files, lfh)
+   self.in_open_file = false
+
+   return true
+end
+
+-- @return boolean or (boolean, string): true on success,
+-- false and an error message on failure.
+local function zipwriter_add(self, file)
+   local fin
+   local ok, err = self:open_new_file_in_zip(file)
+   if not ok then
+      err = "error in opening "..file.." in zipfile"
+   else
+      fin = io.open(fs.absolute_name(file), "rb")
+      if not fin then
+         ok = false
+         err = "error opening "..file.." for reading"
+      end
+   end
+   if ok then
+      local data = fin:read("*a")
+      if not data then
+         err = "error reading "..file
+         ok = false
+      else
+         ok = self:write_file_in_zip(data)
+         if not ok then
+            err = "error in writing "..file.." in the zipfile"
+         end
+      end
+   end
+   if fin then
+      fin:close()
+   end
+   if ok then
+      ok = self:close_file_in_zip()
+      if not ok then
+         err = "error in writing "..file.." in the zipfile"
+      end
+   end
+   return ok == true, err
+end
+
+--- Complete the writing of the zipfile.
+-- @param self handle of the zipfile being written.
+-- @return true if succeeded, nil in case of failure.
+local function zipwriter_close(self)
+   local zh = self.ziphandle
+
+   local central_directory_offset = zh:seek()
+
+   local size_of_central_directory = 0
+   -- Central directory structure
+   for _, lfh in ipairs(self.files) do
+      zh:write(CENTRAL_DIRECTORY_SIGNATURE) -- signature
+      zh:write(number_to_lestring(3, 2)) -- version made by: UNIX
+      zh:write(number_to_lestring(20, 2)) -- version needed to extract: 2.0
+      zh:write(number_to_lestring(0, 2)) -- general purpose bit flag
+      zh:write(number_to_lestring(8, 2)) -- compression method: deflate
+      zh:write(number_to_lestring(lfh.last_mod_file_time, 2))
+      zh:write(number_to_lestring(lfh.last_mod_file_date, 2))
+      zh:write(number_to_lestring(lfh.crc32, 4))
+      zh:write(number_to_lestring(lfh.compressed_size, 4))
+      zh:write(number_to_lestring(lfh.uncompressed_size, 4))
+      zh:write(number_to_lestring(lfh.file_name_length, 2))
+      zh:write(number_to_lestring(lfh.extra_field_length, 2))
+      zh:write(number_to_lestring(0, 2)) -- file comment length
+      zh:write(number_to_lestring(0, 2)) -- disk number start
+      zh:write(number_to_lestring(0, 2)) -- internal file attributes
+      zh:write(number_to_lestring(lfh.external_attr, 4)) -- external file attributes
+      zh:write(number_to_lestring(lfh.offset, 4)) -- relative offset of local header
+      zh:write(lfh.file_name)
+      size_of_central_directory = size_of_central_directory + 46 + lfh.file_name_length
+   end
+
+   -- End of central directory record
+   zh:write(END_OF_CENTRAL_DIR_SIGNATURE) -- signature
+   zh:write(number_to_lestring(0, 2)) -- number of this disk
+   zh:write(number_to_lestring(0, 2)) -- number of disk with start of central directory
+   zh:write(number_to_lestring(#self.files, 2)) -- total number of entries in the central dir on this disk
+   zh:write(number_to_lestring(#self.files, 2)) -- total number of entries in the central dir
+   zh:write(number_to_lestring(size_of_central_directory, 4))
+   zh:write(number_to_lestring(central_directory_offset, 4))
+   zh:write(number_to_lestring(0, 2)) -- zip file comment length
+   zh:close()
+
+   return true
+end
+
+--- Return a zip handle open for writing.
+-- @param name filename of the zipfile to be created.
+-- @return a zip handle, or nil in case of error.
+function zip.new_zipwriter(name)
+
+   local zw = {}
+
+   zw.ziphandle = io.open(fs.absolute_name(name), "wb")
+   if not zw.ziphandle then
+      return nil
+   end
+   zw.files = {}
+   zw.in_open_file = false
+
+   zw.add = zipwriter_add
+   zw.close = zipwriter_close
+   zw.open_new_file_in_zip = zipwriter_open_new_file_in_zip
+   zw.write_file_in_zip = zipwriter_write_file_in_zip
+   zw.close_file_in_zip = zipwriter_close_file_in_zip
+
+   return zw
+end
+
+--- Compress files in a .zip archive.
+-- @param zipfile string: pathname of .zip archive to be created.
+-- @param ... Filenames to be stored in the archive are given as
+-- additional arguments.
+-- @return boolean or (boolean, string): true on success,
+-- false and an error message on failure.
+function zip.zip(zipfile, ...)
+   local zw = zip.new_zipwriter(zipfile)
+   if not zw then
+      return nil, "error opening "..zipfile
+   end
+
+   local args = pack(...)
+   local ok, err
+   for i=1, args.n do
+      local file = args[i]
+      if fs.is_dir(file) then
+         for _, entry in pairs(fs.find(file)) do
+            local fullname = dir.path(file, entry)
+            if fs.is_file(fullname) then
+               ok, err = zw:add(fullname)
+               if not ok then break end
+            end
+         end
+      else
+         ok, err = zw:add(file)
+         if not ok then break end
+      end
+   end
+
+   zw:close()
+   return ok, err
+end
+
+
+local function ziptime_to_luatime(ztime, zdate)
+   local date = {
+      year = shr(zdate, 9) + 1980,
+      month = shr(lowbits(zdate, 9), 5),
+      day = lowbits(zdate, 5),
+      hour = shr(ztime, 11),
+      min = shr(lowbits(ztime, 11), 5),
+      sec = lowbits(ztime, 5) * 2,
+   }
+
+   if date.month == 0 then date.month = 1 end
+   if date.day == 0 then date.day = 1 end
+
+   return date
+end
+
+local function read_file_in_zip(zh, cdr)
+   local sig = zh:read(4)
+   if sig ~= LOCAL_FILE_HEADER_SIGNATURE then
+      return nil, "failed reading Local File Header signature"
+   end
+
+   -- Skip over the rest of the zip file header. See
+   -- zipwriter_close_file_in_zip for the format.
+   zh:seek("cur", 22)
+   local file_name_length = lestring_to_number(zh:read(2))
+   local extra_field_length = lestring_to_number(zh:read(2))
+   zh:read(file_name_length)
+   zh:read(extra_field_length)
+
+   local data = zh:read(cdr.compressed_size)
+
+   local uncompressed
+   if cdr.compression_method == 8 then
+      uncompressed = zlib_uncompress(data, "raw")
+   elseif cdr.compression_method == 0 then
+      uncompressed = data
+   else
+      return nil, "unknown compression method " .. cdr.compression_method
+   end
+
+   if #uncompressed ~= cdr.uncompressed_size then
+      return nil, "uncompressed size doesn't match"
+   end
+   if cdr.crc32 ~= zlib_crc32(uncompressed) then
+      return nil, "crc32 failed (expected " .. cdr.crc32 .. ") - data: " .. uncompressed
+   end
+
+   return uncompressed
+end
+
+local function process_end_of_central_dir(zh)
+   local at, err = zh:seek("end", -22)
+   if not at then
+      return nil, err
+   end
+
+   while true do
+      local sig = zh:read(4)
+      if sig == END_OF_CENTRAL_DIR_SIGNATURE then
+         break
+      end
+      at = at - 1
+      local at1, err = zh:seek("set", at)
+      if at1 ~= at then
+         return nil, "Could not find End of Central Directory signature"
+      end
+   end
+
+   -- number of this disk (2 bytes)
+   -- number of the disk with the start of the central directory (2 bytes)
+   -- total number of entries in the central directory on this disk (2 bytes)
+   -- total number of entries in the central directory (2 bytes)
+   zh:seek("cur", 6)
+
+   local central_directory_entries = lestring_to_number(zh:read(2))
+
+   -- central directory size (4 bytes)
+   zh:seek("cur", 4)
+
+   local central_directory_offset = lestring_to_number(zh:read(4))
+
+   return central_directory_entries, central_directory_offset
+end
+
+local function process_central_dir(zh, cd_entries)
+
+   local files = {}
+
+   for i = 1, cd_entries do
+      local sig = zh:read(4)
+      if sig ~= CENTRAL_DIRECTORY_SIGNATURE then
+         return nil, "failed reading Central Directory signature"
+      end
+
+      local cdr = {}
+      files[i] = cdr
+
+      cdr.version_made_by = lestring_to_number(zh:read(2))
+      cdr.version_needed = lestring_to_number(zh:read(2))
+      cdr.bitflag = lestring_to_number(zh:read(2))
+      cdr.compression_method = lestring_to_number(zh:read(2))
+      cdr.last_mod_file_time = lestring_to_number(zh:read(2))
+      cdr.last_mod_file_date = lestring_to_number(zh:read(2))
+      cdr.last_mod_luatime = ziptime_to_luatime(cdr.last_mod_file_time, cdr.last_mod_file_date)
+      cdr.crc32 = lestring_to_number(zh:read(4))
+      cdr.compressed_size = lestring_to_number(zh:read(4))
+      cdr.uncompressed_size = lestring_to_number(zh:read(4))
+      cdr.file_name_length = lestring_to_number(zh:read(2))
+      cdr.extra_field_length = lestring_to_number(zh:read(2))
+      cdr.file_comment_length = lestring_to_number(zh:read(2))
+      cdr.disk_number_start = lestring_to_number(zh:read(2))
+      cdr.internal_attr = lestring_to_number(zh:read(2))
+      cdr.external_attr = lestring_to_number(zh:read(4))
+      cdr.offset = lestring_to_number(zh:read(4))
+      cdr.file_name = zh:read(cdr.file_name_length)
+      cdr.extra_field = zh:read(cdr.extra_field_length)
+      cdr.file_comment = zh:read(cdr.file_comment_length)
+   end
+   return files
+end
+
+--- Uncompress files from a .zip archive.
+-- @param zipfile string: pathname of .zip archive to be created.
+-- @return boolean or (boolean, string): true on success,
+-- false and an error message on failure.
+function zip.unzip(zipfile)
+   zipfile = fs.absolute_name(zipfile)
+   local zh, err = io.open(zipfile, "rb")
+   if not zh then
+      return nil, err
+   end
+
+   local cd_entries, cd_offset = process_end_of_central_dir(zh)
+   if not cd_entries then
+      return nil, cd_offset
+   end
+
+   local ok, err = zh:seek("set", cd_offset)
+   if not ok then
+      return nil, err
+   end
+
+   local files, err = process_central_dir(zh, cd_entries)
+   if not files then
+      return nil, err
+   end
+
+   for _, cdr in ipairs(files) do
+      local file = cdr.file_name
+      if file:sub(#file) == "/" then
+         local ok, err = fs.make_dir(dir.path(fs.current_dir(), file))
+         if not ok then
+            return nil, err
+         end
+      else
+         local base = dir.dir_name(file)
+         if base ~= "" then
+            base = dir.path(fs.current_dir(), base)
+            if not fs.is_dir(base) then
+               local ok, err = fs.make_dir(base)
+               if not ok then
+                  return nil, err
+               end
+            end
+         end
+
+         local ok, err = zh:seek("set", cdr.offset)
+         if not ok then
+            return nil, err
+         end
+
+         local contents, err = read_file_in_zip(zh, cdr)
+         if not contents then
+            return nil, err
+         end
+         local pathname = dir.path(fs.current_dir(), file)
+         local wf, err = io.open(pathname, "wb")
+         if not wf then
+            zh:close()
+            return nil, err
+         end
+         wf:write(contents)
+         wf:close()
+
+         if cdr.external_attr > 0 then
+            fs.set_permissions(pathname, "exec", "all")
+         else
+            fs.set_permissions(pathname, "read", "all")
+         end
+         fs.set_time(pathname, cdr.last_mod_luatime)
+      end
+   end
+   zh:close()
+   return true
+end
+
+function zip.gzip(input_filename, output_filename)
+   assert(type(input_filename) == "string")
+   assert(output_filename == nil or type(output_filename) == "string")
+
+   if not output_filename then
+      output_filename = input_filename .. ".gz"
+   end
+
+   local fn = fun.partial(fun.flip(zlib_compress), "gzip")
+   return fs.filter_file(fn, input_filename, output_filename)
+end
+
+function zip.gunzip(input_filename, output_filename)
+   assert(type(input_filename) == "string")
+   assert(output_filename == nil or type(output_filename) == "string")
+
+   if not output_filename then
+      output_filename = input_filename:gsub("%.gz$", "")
+   end
+
+   local fn = fun.partial(fun.flip(zlib_uncompress), "gzip")
+   return fs.filter_file(fn, input_filename, output_filename)
+end
+
+return zip
diff --git a/src/luarocks/type_check.tl b/src/luarocks/type_check.tl
index 1252133d..f69f1441 100644
--- a/src/luarocks/type_check.tl
+++ b/src/luarocks/type_check.tl
@@ -1,6 +1,7 @@
 
 local record type_check
    MAGIC_PLATFORMS: integer
+   type_check_table: function(version: string, tbl: {any: any}, typetbl: {string: string}, context: string): boolean, string --! tbl and typetbl types)
 end
 
 local cfg = require("luarocks.core.cfg")