rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/luarocks/tools/tar.lua

@@ -0,0 +1,144 @@
+
+--- A pure-Lua implementation of untar (unpacking .tar archives)
+module("luarocks.tools.tar", package.seeall)
+
+local fs = require("luarocks.fs")
+local dir = require("luarocks.dir")
+local util = require("luarocks.util")
+
+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
+   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
+   for i = 1,148 do
+      sum = sum + block:byte(i)
+   end
+   for i = 157,500 do
+      sum = sum + block:byte(i)
+   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))
+   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 "..header.magic
+   end
+   if header.version ~= "00" and header.version ~= " \0" then
+      return false, "Unknown version "..header.version
+   end
+   if not checksum_header(block) == header.chksum then
+      return false, "Failed header checksum"
+   end
+   return header
+end
+
+function untar(filename, destdir)
+   assert(type(filename) == "string")
+   assert(type(destdir) == "string")
+
+   local tar_handle = io.open(filename, "r")
+   if not tar_handle then return nil, "Error opening file "..filename end
+   
+   local long_name, long_link_name
+   while true do
+      local block
+      repeat 
+         block = tar_handle:read(blocksize)
+      until (not block) or checksum_header(block) > 256
+      if not block then break end
+      local header, err = read_header_block(block)
+      if not header then
+         util.printerr(err)
+      end
+
+      local file_data = tar_handle:read(math.ceil(header.size / blocksize) * blocksize):sub(1,header.size)
+
+      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)
+      if header.typeflag == "directory" then
+         fs.make_dir(pathname)
+      elseif header.typeflag == "file" then
+         local dirname = dir.dir_name(pathname)
+         if dirname ~= "" then
+            fs.make_dir(dirname)
+         end
+         local file_handle = io.open(pathname, "wb")
+         file_handle:write(file_data)
+         file_handle:close()
+         fs.set_time(pathname, header.mtime)
+         if fs.chmod then
+            fs.chmod(pathname, header.mode)
+         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
+   return true
+end

data/vendor/lua/lib/lua/luarocks/tools/zip.lua

@@ -0,0 +1,245 @@
+
+--- A Lua implementation of .zip file archiving (used for creating .rock files),
+-- using only lua-zlib.
+module("luarocks.tools.zip", package.seeall)
+
+local zlib = require("zlib")
+local fs = require("luarocks.fs")
+local dir = require("luarocks.dir")
+
+local function number_to_bytestring(number, nbytes)
+   local out = {}
+   for i = 1, nbytes do
+      local byte = number % 256
+      table.insert(out, string.char(byte))
+      number = (number - byte) / 256
+   end
+   return table.concat(out)
+end
+
+--- 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.crc32 = 0 -- initial value
+   lfh.compressed_size = 0 -- unknown yet
+   lfh.uncompressed_size = 0 -- unknown yet
+   lfh.file_name_length = #filename
+   lfh.extra_field_length = 0
+   lfh.file_name = filename:gsub("\\", "/")
+   lfh.external_attr = 0 -- TODO properly store permissions
+   self.in_open_file = true
+   self.data = {}
+   return true
+end
+
+--- Write data to the file currently being stored in the zipfile.
+-- @param self handle of the zipfile being written.
+-- @param buf string containing data to be written.
+-- @return true if succeeded, nil in case of failure.
+local function zipwriter_write_file_in_zip(self, buf)
+   if not self.in_open_file then
+      return nil
+   end
+   local lfh = self.local_file_header
+   local cbuf = zlib.compress(buf):sub(3, -5)
+   lfh.crc32 = zlib.crc32(lfh.crc32, buf)
+   lfh.compressed_size = lfh.compressed_size + #cbuf
+   lfh.uncompressed_size = lfh.uncompressed_size + #buf
+   table.insert(self.data, cbuf)
+   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(number_to_bytestring(0x04034b50, 4)) -- signature
+   zh:write(number_to_bytestring(20, 2)) -- version needed to extract: 2.0
+   zh:write(number_to_bytestring(0, 2)) -- general purpose bit flag
+   zh:write(number_to_bytestring(8, 2)) -- compression method: deflate
+   zh:write(number_to_bytestring(lfh.last_mod_file_time, 2))
+   zh:write(number_to_bytestring(lfh.last_mod_file_date, 2))
+   zh:write(number_to_bytestring(lfh.crc32, 4))
+   zh:write(number_to_bytestring(lfh.compressed_size, 4))
+   zh:write(number_to_bytestring(lfh.uncompressed_size, 4))
+   zh:write(number_to_bytestring(lfh.file_name_length, 2))
+   zh:write(number_to_bytestring(lfh.extra_field_length, 2))
+   zh:write(lfh.file_name)
+
+   -- File data   
+   for _, cbuf in ipairs(self.data) do
+      zh:write(cbuf)
+   end
+   
+   -- Data descriptor
+   zh:write(number_to_bytestring(lfh.crc32, 4))
+   zh:write(number_to_bytestring(lfh.compressed_size, 4))
+   zh:write(number_to_bytestring(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 buf = fin:read("*a")
+      if not buf then
+         err = "error reading "..file
+         ok = false
+      else
+         ok = self:write_file_in_zip(buf)
+         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(number_to_bytestring(0x02014b50, 4)) -- signature
+      zh:write(number_to_bytestring(3, 2)) -- version made by: UNIX
+      zh:write(number_to_bytestring(20, 2)) -- version needed to extract: 2.0
+      zh:write(number_to_bytestring(0, 2)) -- general purpose bit flag
+      zh:write(number_to_bytestring(8, 2)) -- compression method: deflate
+      zh:write(number_to_bytestring(lfh.last_mod_file_time, 2))
+      zh:write(number_to_bytestring(lfh.last_mod_file_date, 2))
+      zh:write(number_to_bytestring(lfh.crc32, 4))
+      zh:write(number_to_bytestring(lfh.compressed_size, 4))
+      zh:write(number_to_bytestring(lfh.uncompressed_size, 4))
+      zh:write(number_to_bytestring(lfh.file_name_length, 2))
+      zh:write(number_to_bytestring(lfh.extra_field_length, 2))
+      zh:write(number_to_bytestring(0, 2)) -- file comment length
+      zh:write(number_to_bytestring(0, 2)) -- disk number start
+      zh:write(number_to_bytestring(0, 2)) -- internal file attributes
+      zh:write(number_to_bytestring(lfh.external_attr, 4)) -- external file attributes
+      zh:write(number_to_bytestring(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(number_to_bytestring(0x06054b50, 4)) -- signature
+   zh:write(number_to_bytestring(0, 2)) -- number of this disk
+   zh:write(number_to_bytestring(0, 2)) -- number of disk with start of central directory
+   zh:write(number_to_bytestring(#self.files, 2)) -- total number of entries in the central dir on this disk
+   zh:write(number_to_bytestring(#self.files, 2)) -- total number of entries in the central dir
+   zh:write(number_to_bytestring(size_of_central_directory, 4))
+   zh:write(number_to_bytestring(central_directory_offset, 4))
+   zh:write(number_to_bytestring(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 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(zipfile, ...)
+   local zw = new_zipwriter(zipfile)
+   if not zw then
+      return nil, "error opening "..zipfile
+   end
+
+   local ok, err
+   for _, file in pairs({...}) do
+      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
+
+   local ok = zw:close()
+   if not ok then
+      return false, "error closing "..zipfile
+   end
+   return ok, err
+end
+

data/vendor/lua/lib/lua/luarocks/type_check.lua

@@ -0,0 +1,267 @@
+
+--- Type-checking functions.
+-- Functions and definitions for doing a basic lint check on files
+-- loaded by LuaRocks.
+module("luarocks.type_check", package.seeall)
+
+local cfg = require("luarocks.cfg")
+
+rockspec_format = "1.0"
+
+rockspec_types = {
+   rockspec_format = "string",
+   MUST_package = "string",
+   MUST_version = "[%w.]+-[%d]+",
+   description = {
+      summary = "string",
+      detailed = "string",
+      homepage = "string",
+      license = "string",
+      maintainer = "string"
+   },
+   dependencies = {
+      platforms = {},
+      ANY = "string"
+   },
+   supported_platforms = {
+      ANY = "string"
+   },
+   external_dependencies = {
+      platforms = {},
+      ANY = {
+         program = "string",
+         header = "string",
+         library = "string"
+      }
+   },
+   MUST_source = {
+      platforms = {},
+      MUST_url = "string",
+      md5 = "string",
+      file = "string",
+      dir = "string",
+      tag = "string",
+      branch = "string",
+      module = "string",
+      cvs_tag = "string",
+      cvs_module = "string"
+   },
+   build = {
+      platforms = {},
+      type = "string",
+      install = {
+         lua = {
+            MORE = true
+         },
+         lib = {
+            MORE = true
+         },
+         conf = {
+            MORE = true
+         },
+         bin = {
+            MORE = true
+         }
+      },
+      copy_directories = {
+         ANY = "string"
+      },
+      MORE = true
+   },
+   hooks = {
+      platforms = {},
+      post_install = "string"
+   }
+}
+
+function load_extensions()
+   rockspec_format = "1.1"
+   rockspec_types.deploy = {
+      wrap_bin_scripts = true,
+   }
+end
+
+if cfg.use_extensions then
+   load_extensions()
+end
+
+rockspec_types.build.platforms.ANY = rockspec_types.build
+rockspec_types.dependencies.platforms.ANY = rockspec_types.dependencies
+rockspec_types.external_dependencies.platforms.ANY = rockspec_types.external_dependencies
+rockspec_types.MUST_source.platforms.ANY = rockspec_types.MUST_source
+rockspec_types.hooks.platforms.ANY = rockspec_types.hooks
+
+manifest_types = {
+   MUST_repository = {
+      -- packages
+      ANY = {
+         -- versions
+         ANY = {
+            -- items
+            ANY = {
+               MUST_arch = "string",
+               modules = { ANY = "string" },
+               commands = { ANY = "string" },
+               dependencies = { ANY = "string" },
+               -- TODO: to be extended with more metadata.
+            }
+         }
+      }
+   },
+   MUST_modules = {
+      -- modules
+      ANY = {
+         -- providers
+         ANY = "string"
+      }
+   },
+   MUST_commands = {
+      -- modules
+      ANY = {
+         -- commands
+         ANY = "string"
+      }
+   },
+   dependencies = {
+      -- each module
+      ANY = {
+         -- each version
+         ANY = {
+            -- each dependency
+            ANY = {
+               name = "string",
+               constraints = {
+                  ANY = {
+                     no_upgrade = "boolean",
+                     op = "string",
+                     version = {
+                        string = "string",
+                        ANY = 0,
+                     }
+                  }
+               }
+            }
+         }
+      }
+   }
+}
+
+local type_check_table
+
+--- Type check an object.
+-- The object is compared against an archetypical value
+-- matching the expected type -- the actual values don't matter,
+-- only their types. Tables are type checked recursively.
+-- @param name any: The object name (for error messages).
+-- @param item any: The object being checked.
+-- @param expected any: The reference object. In case of a table,
+-- its is structured as a type reference table.
+-- @param context string: A string indicating the "context" where the
+-- error occurred (such as the name of the table the item is a part of),
+-- to be used by error messages.
+-- @return boolean or (nil, string): true if type checking
+-- succeeded, or nil and an error message if it failed.
+-- @see type_check_table
+local function type_check_item(name, item, expected, context)
+   name = tostring(name)
+
+   local item_type = type(item)
+   local expected_type = type(expected)
+   if expected_type == "number" then
+      if not tonumber(item) then
+         return nil, "Type mismatch on field "..context..name..": expected a number"
+      end
+   elseif expected_type == "string" then
+      if not tostring(item) then
+         return nil, "Type mismatch on field "..context..name..": expected a value convertible to string"
+      end
+      if expected ~= "string" then
+         if not item:match("^"..expected.."$") then
+            return nil, "Type mismatch on field "..context..name..": invalid value "..item
+         end
+      end
+   elseif expected_type == "table" then
+      if item_type ~= expected_type then
+         return nil, "Type mismatch on field "..context..name..": expected a table"
+      else
+         return type_check_table(item, expected, context..name..".")
+      end
+   elseif item_type ~= expected_type then
+      return nil, "Type mismatch on field "..context..name..": expected a "..expected_type
+   end
+   return true
+end
+
+--- Type check the contents of a table.
+-- The table's contents are compared against a reference table,
+-- which contains the recognized fields, with archetypical values
+-- matching the expected types -- the actual values of items in the
+-- reference table don't matter, only their types (ie, for field x
+-- in tbl that is correctly typed, type(tbl.x) == type(types.x)).
+-- If the reference table contains a field called MORE, then
+-- unknown fields in the checked table are accepted.
+-- If it contains a field called ANY, then its type will be 
+-- used to check any unknown fields. If a field is prefixed
+-- with MUST_, it is mandatory; its absence from the table is
+-- a type error.
+-- Tables are type checked recursively.
+-- @param tbl table: The table to be type checked.
+-- @param types table: The reference table, containing
+-- values for recognized fields in the checked table.
+-- @param context string: A string indicating the "context" where the
+-- error occurred (such as the name of the table the item is a part of),
+-- to be used by error messages.
+-- @return boolean or (nil, string): true if type checking
+-- succeeded, or nil and an error message if it failed.
+type_check_table = function(tbl, types, context)
+   assert(type(tbl) == "table")
+   assert(type(types) == "table")
+   for k, v in pairs(tbl) do
+      local t = types[k] or (type(k) == "string" and types["MUST_"..k]) or types.ANY
+      if t then 
+         local ok, err = type_check_item(k, v, t, context)
+         if not ok then return nil, err end
+      elseif types.MORE then
+         -- Accept unknown field
+      else
+         if not cfg.accept_unknown_fields then
+            return nil, "Unknown field "..k
+         end
+      end
+   end
+   for k, v in pairs(types) do
+      local mandatory_key = k:match("^MUST_(.+)")
+      if mandatory_key then
+         if not tbl[mandatory_key] then
+            return nil, "Mandatory field "..context..mandatory_key.." is missing."
+         end
+      end
+   end
+   return true
+end
+
+--- Type check a rockspec table.
+-- Verify the correctness of elements from a 
+-- rockspec table, reporting on unknown fields and type
+-- mismatches.
+-- @return boolean or (nil, string): true if type checking
+-- succeeded, or nil and an error message if it failed.
+function type_check_rockspec(rockspec)
+   assert(type(rockspec) == "table")
+   if rockspec.rockspec_format then
+      -- relies on global state
+      load_extensions()
+   end
+   return type_check_table(rockspec, rockspec_types, "")
+end
+
+--- Type check a manifest table.
+-- Verify the correctness of elements from a 
+-- manifest table, reporting on unknown fields and type
+-- mismatches.
+-- @return boolean or (nil, string): true if type checking
+-- succeeded, or nil and an error message if it failed.
+function type_check_manifest(manifest)
+   assert(type(manifest) == "table")
+   return type_check_table(manifest, manifest_types, "")
+end