util test

4 files changed, 858 insertions, 1 deletions

diff --git a/src/luarocks/cmd/install.lua b/src/luarocks/cmd/install.lua
index 4f27e471..b50271f0 100644
--- a/src/luarocks/cmd/install.lua
+++ b/src/luarocks/cmd/install.lua
@@ -54,7 +54,7 @@ function install.add_to_parser(parser)
    parser:flag("--sign"):hidden(true)
 end
 
-install.opts = util.opts_table("install.opts", { --WORK
+install.opts = util.opts_table("install.opts", { --WORK util.opts_table doesn't exist. Make a record
    namespace = "string?",
    keep = "boolean",
    force = "boolean",
diff --git a/src/luarocks/type_check.tl b/src/luarocks/type_check.tl
new file mode 100644
index 00000000..0e8ce60f
--- /dev/null
+++ b/src/luarocks/type_check.tl
@@ -0,0 +1,213 @@
+
+local type_check = {}
+
+local cfg = require("luarocks.core.cfg")
+local fun = require("luarocks.fun")
+local util = require("luarocks.util")
+local vers = require("luarocks.core.vers")
+--------------------------------------------------------------------------------
+
+-- A magic constant that is not used anywhere in a schema definition
+-- and retains equality when the table is deep-copied.
+type_check.MAGIC_PLATFORMS = 0xEBABEFAC
+
+do
+   local function fill_in_version(tbl, version)
+      for _, v in pairs(tbl) do
+         if v is table then
+            if v._version == nil then
+               v._version = version
+            end
+            fill_in_version(v)
+         end
+      end
+   end
+
+   local function expand_magic_platforms(tbl)
+      for k,v in pairs(tbl) do
+         if v == type_check.MAGIC_PLATFORMS then
+            tbl[k] = {
+               _any = util.deep_copy(tbl)
+            }
+            tbl[k]._any[k] = nil
+         elseif type(v) == "table" then
+            expand_magic_platforms(v)
+         end
+      end
+   end
+
+   -- Build a table of schemas.
+   -- @param versions a table where each key is a version number as a string,
+   -- and the value is a schema specification. Schema versions are considered
+   -- incremental: version "2.0" only needs to specify what's new/changed from
+   -- version "1.0".
+   function type_check.declare_schemas(inputs)
+      local schemas = {}
+      local parent_version
+
+      local versions = fun.reverse_in(fun.sort_in(util.keys(inputs), vers.compare_versions))
+
+      for _, version in ipairs(versions) do
+         local schema = inputs[version]
+         if parent_version ~= nil then
+            local copy = util.deep_copy(schemas[parent_version])
+            util.deep_merge(copy, schema)
+            schema = copy
+         end
+         fill_in_version(schema, version)
+         expand_magic_platforms(schema)
+         parent_version = version
+         schemas[version] = schema
+      end
+
+      return schemas, versions
+   end
+end
+
+--------------------------------------------------------------------------------
+
+local function check_version(version, typetbl, context)
+   local typetbl_version = typetbl._version or "1.0"
+   if vers.compare_versions(typetbl_version, version) then
+      if context == "" then
+         return nil, "Invalid rockspec_format version number in rockspec? Please fix rockspec accordingly."
+      else
+         return nil, context.." is not supported in rockspec format "..version.." (requires version "..typetbl_version.."), please fix the rockspec_format field accordingly."
+      end
+   end
+   return true
+end
+
+--- 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 version string: The version of the item.
+-- @param item any: The object being checked.
+-- @param typetbl any: The type-checking table for the object.
+-- @param context string: A string indicating the "context" where the
+-- error occurred (the full table path), for 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(version, item, typetbl, context)
+   assert(type(version) == "string")
+
+   if typetbl._version and typetbl._version ~= "1.0" then
+      local ok, err = check_version(version, typetbl, context)
+      if not ok then
+         return nil, err
+      end
+   end
+
+   local item_type = type(item) or "nil"
+   local expected_type = typetbl._type or "table"
+
+   if expected_type == "number" then
+      if not tonumber(item) then
+         return nil, "Type mismatch on field "..context..": expected a number"
+      end
+   elseif expected_type == "string" then
+      if item_type ~= "string" then
+         return nil, "Type mismatch on field "..context..": expected a string, got "..item_type
+      end
+      local pattern = typetbl._pattern
+      if pattern then
+         if not item:match("^"..pattern.."$") then
+            local what = typetbl._name or ("'"..pattern.."'")
+            return nil, "Type mismatch on field "..context..": invalid value '"..item.."' does not match " .. what
+         end
+      end
+   elseif expected_type == "table" then
+      if item_type ~= expected_type then
+         return nil, "Type mismatch on field "..context..": expected a table"
+      else
+         return type_check.type_check_table(version, item, typetbl, context)
+      end
+   elseif item_type ~= expected_type then
+      return nil, "Type mismatch on field "..context..": expected "..expected_type
+   end
+   return true
+end
+
+local function mkfield(context, field)
+   if context == "" then
+      return tostring(field)
+   elseif type(field) == "string" then
+      return context.."."..field
+   else
+      return context.."["..tostring(field).."]"
+   end
+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 version string: The version of tbl.
+-- @param tbl table: The table to be type checked.
+-- @param typetbl table: The type-checking 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.
+function type_check.type_check_table(version, tbl, typetbl, context)
+   assert(type(version) == "string")
+   assert(type(tbl) == "table")
+   assert(type(typetbl) == "table")
+
+   local ok, err = check_version(version, typetbl, context)
+   if not ok then
+      return nil, err
+   end
+
+   for k, v in pairs(tbl) do
+      local t = typetbl[k] or typetbl._any
+      if t then
+         local ok, err = type_check_item(version, v, t, mkfield(context, k))
+         if not ok then return nil, err end
+      elseif typetbl._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(typetbl) do
+      if k:sub(1,1) ~= "_" and v._mandatory then
+         if not tbl[k] then
+            return nil, "Mandatory field "..mkfield(context, k).." is missing."
+         end
+      end
+   end
+   return true
+end
+
+function type_check.check_undeclared_globals(globals, typetbl)
+   local undeclared = {}
+   for glob, _ in pairs(globals) do
+      if not (typetbl[glob] or typetbl["MUST_"..glob]) then
+         table.insert(undeclared, glob)
+      end
+   end
+   if #undeclared == 1 then
+      return nil, "Unknown variable: "..undeclared[1]
+   elseif #undeclared > 1 then
+      return nil, "Unknown variables: "..table.concat(undeclared, ", ")
+   end
+   return true
+end
+
+return type_check
diff --git a/src/luarocks/util.lua b/src/luarocks/util.lua
new file mode 100644
index 00000000..59aff9a7
--- /dev/null
+++ b/src/luarocks/util.lua
@@ -0,0 +1,643 @@
+local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 then local p, m = pcall(require, 'compat53.module'); if p then _tl_compat = m end end; local debug = _tl_compat and _tl_compat.debug or debug; local io = _tl_compat and _tl_compat.io or io; local ipairs = _tl_compat and _tl_compat.ipairs or ipairs; local os = _tl_compat and _tl_compat.os or os; local package = _tl_compat and _tl_compat.package or package; local pairs = _tl_compat and _tl_compat.pairs or pairs; local string = _tl_compat and _tl_compat.string or string; local table = _tl_compat and _tl_compat.table or table; local _tl_table_unpack = unpack or table.unpack
+
+
+
+
+
+local core = require("luarocks.core.util")
+local cfg = require("luarocks.core.cfg")
+
+local util = {Fn = {}, Parser = {}, }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+util.cleanup_path = core.cleanup_path
+util.split_string = core.split_string
+util.sortedpairs = core.sortedpairs
+util.deep_merge = core.deep_merge
+util.deep_merge_under = core.deep_merge_under
+util.popen_read = core.popen_read
+util.show_table = core.show_table
+util.printerr = core.printerr
+util.warning = core.warning
+util.keys = core.keys
+util.matchquote = core.matchquote
+
+
+
+
+
+
+local scheduled_functions = {}
+
+
+
+
+
+
+
+
+function util.schedule_function(f, ...)
+   local item = { fn = f, args = table.pack(...) }
+   table.insert(scheduled_functions, item)
+   return item
+end
+
+
+
+
+
+function util.remove_scheduled_function(item)
+   for k, v in ipairs(scheduled_functions) do
+      if v == item then
+         table.remove(scheduled_functions, k)
+         return
+      end
+   end
+end
+
+
+
+
+
+
+function util.run_scheduled_functions()
+   local fs = require("luarocks.fs")
+   if fs.change_dir_to_root then
+      fs.change_dir_to_root()
+   end
+   for i = #scheduled_functions, 1, -1 do
+      local item = scheduled_functions[i]
+      item.fn(_tl_table_unpack(item.args, 1, item.args.n))
+   end
+end
+
+local var_format_pattern = "%$%((%a[%a%d_]+)%)"
+
+
+
+
+
+
+
+
+
+
+
+function util.warn_if_not_used(var_defs, needed_set, msg)
+   local seen = {}
+   for _, val in pairs(var_defs) do
+      for used in val:gmatch(var_format_pattern) do
+         seen[used] = true
+      end
+   end
+   for var, _ in pairs(needed_set) do
+      if not seen[var] then
+         util.warning(msg:format(var))
+      end
+   end
+end
+
+
+
+
+local function warn_failed_matches(line)
+   local any_failed = false
+   if line:match(var_format_pattern) then
+      for unmatched in line:gmatch(var_format_pattern) do
+         util.warning("unmatched variable " .. unmatched)
+         any_failed = true
+      end
+   end
+   return any_failed
+end
+
+
+
+
+
+
+
+
+
+function util.variable_substitutions(tbl, vars)
+
+   local updated = {}
+   for k, v in pairs(tbl) do
+      if type(v) == "string" then
+         updated[k] = string.gsub(v, var_format_pattern, vars)
+         if warn_failed_matches(updated[k]) then
+            updated[k] = updated[k]:gsub(var_format_pattern, "")
+         end
+      end
+   end
+   for k, v in pairs(updated) do
+      tbl[k] = v
+   end
+end
+
+function util.lua_versions(sort)
+   local versions = { "5.1", "5.2", "5.3", "5.4" }
+   local i = 0
+   if sort == "descending" then
+      i = #versions + 1
+      return function()
+         i = i - 1
+         return versions[i]
+      end
+   else
+      return function()
+         i = i + 1
+         return versions[i]
+      end
+   end
+end
+
+function util.lua_path_variables()
+   local lpath_var = "LUA_PATH"
+   local lcpath_var = "LUA_CPATH"
+
+   local lv = cfg.lua_version:gsub("%.", "_")
+   if lv ~= "5_1" then
+      if os.getenv("LUA_PATH_" .. lv) then
+         lpath_var = "LUA_PATH_" .. lv
+      end
+      if os.getenv("LUA_CPATH_" .. lv) then
+         lcpath_var = "LUA_CPATH_" .. lv
+      end
+   end
+   return lpath_var, lcpath_var
+end
+
+function util.starts_with(s, prefix)
+   return s:sub(1, #prefix) == prefix
+end
+
+
+function util.printout(...)
+   io.stdout:write(table.concat({ ... }, "\t"))
+   io.stdout:write("\n")
+end
+
+function util.title(msg, porcelain, underline)
+   if porcelain then return end
+   util.printout()
+   util.printout(msg)
+   util.printout((underline or "-"):rep(#msg))
+   util.printout()
+end
+
+function util.this_program(default)
+   local i = 1
+   local last, cur = default, default
+   while i do
+      local dbg = debug and debug.getinfo(i, "S")
+      if not dbg then break end
+      last = cur
+      cur = dbg.source
+      i = i + 1
+   end
+   local prog = last:sub(1, 1) == "@" and last:sub(2) or last
+
+
+   local lrdir, binpath = prog:match("^(.*)/lib/luarocks/rocks%-[0-9.]*/[^/]+/[^/]+(/bin/[^/]+)$")
+   if lrdir then
+
+      return lrdir .. binpath
+   end
+
+   return prog
+end
+
+function util.format_rock_name(name, namespace, version)
+   return (namespace and namespace .. "/" or "") .. name .. (version and " " .. version or "")
+end
+
+function util.deps_mode_option(parser, program)
+
+   parser:option("--deps-mode", "How to handle dependencies. Four modes are supported:\n" ..
+   "* all - use all trees from the rocks_trees list for finding dependencies\n" ..
+   "* one - use only the current tree (possibly set with --tree)\n" ..
+   "* order - use trees based on order (use the current tree and all " ..
+   "trees below it on the rocks_trees list)\n" ..
+   "* none - ignore dependencies altogether.\n" ..
+   "The default mode may be set with the deps_mode entry in the configuration file.\n" ..
+   'The current default is "' .. cfg.deps_mode .. '".\n' ..
+   "Type '" .. util.this_program(program or "luarocks") .. "' with no " ..
+   "arguments to see your list of rocks trees."):
+   argname("<mode>"):
+   choices({ "all", "one", "order", "none" })
+   parser:flag("--nodeps"):hidden(true)
+end
+
+function util.see_help(command, program)
+   return "See '" .. util.this_program(program or "luarocks") .. ' help' .. (command and " " .. command or "") .. "'."
+end
+
+function util.see_also(text)
+   local see_also = "See also:\n"
+   if text then
+      see_also = see_also .. text .. "\n"
+   end
+   return see_also .. "   '" .. util.this_program("luarocks") .. " help' for general options and configuration."
+end
+
+function util.announce_install(rockspec)
+   local path = require("luarocks.path")
+
+   local suffix = ""
+   if rockspec.description and rockspec.description.license then
+      suffix = " (license: " .. rockspec.description.license .. ")"
+   end
+
+   util.printout(rockspec.name .. " " .. rockspec.version .. " is now installed in " .. path.root_dir(cfg.root_dir) .. suffix)
+   util.printout()
+end
+
+
+
+
+
+
+
+local function collect_rockspecs(versions, paths, unnamed_paths, subdir)
+   local fs = require("luarocks.fs")
+   local dir = require("luarocks.dir")
+   local path = require("luarocks.path")
+   local vers = require("luarocks.core.vers")
+   if fs.is_dir(subdir) then
+      for file in fs.dir(subdir) do
+         file = dir.path(subdir, file)
+
+         if file:match("rockspec$") and fs.is_file(file) then
+            local rock, version = path.parse_name(file)
+
+            if rock then
+               if not versions[rock] or vers.compare_versions(version, versions[rock]) then
+                  versions[rock] = version
+                  paths[rock] = file
+               end
+            else
+               table.insert(unnamed_paths, file)
+            end
+         end
+      end
+   end
+end
+
+
+
+function util.get_default_rockspec()
+
+   local versions = {}
+   local paths = {}
+   local unnamed_paths = {}
+
+   collect_rockspecs(versions, paths, unnamed_paths, ".")
+   collect_rockspecs(versions, paths, unnamed_paths, "rockspec")
+   collect_rockspecs(versions, paths, unnamed_paths, "rockspecs")
+
+   if #unnamed_paths > 0 then
+
+
+      if #unnamed_paths > 1 then
+         return nil, "Please specify which rockspec file to use."
+      else
+         return unnamed_paths[1]
+      end
+   else
+      local fs = require("luarocks.fs")
+      local dir = require("luarocks.dir")
+      local basename = dir.base_name(fs.current_dir())
+
+      if paths[basename] then
+         return paths[basename]
+      end
+
+      local rock = next(versions)
+
+      if rock then
+
+         if next(versions, rock) ~= nil then
+            return nil, "Please specify which rockspec file to use."
+         else
+            return paths[rock]
+         end
+      else
+         return nil, "Argument missing: please specify a rockspec to use on current directory."
+      end
+   end
+end
+
+
+
+
+function util.LQ(s)
+   return ("%q"):format(s)
+end
+
+
+
+
+function util.split_namespace(ns_name)
+   local p1, p2 = ns_name:match("^([^/]+)/([^/]+)$")
+   if p1 then
+      return p2, p1
+   end
+   return ns_name
+end
+
+
+function util.namespaced_name_action(args, target, ns_name)
+
+   if not ns_name then
+      return
+   end
+
+   if ns_name:match("%.rockspec$") or ns_name:match("%.rock$") then
+      args[target] = ns_name
+   else
+      local name, namespace = util.split_namespace(ns_name)
+      args[target] = name:lower()
+      if namespace then
+         args.namespace = namespace:lower()
+      end
+   end
+end
+
+function util.deep_copy(tbl)
+   local copy = {}
+   for k, v in pairs(tbl) do
+      if type(v) == "table" then
+         copy[k] = util.deep_copy(v)
+      else
+         copy[k] = v
+      end
+   end
+   return copy
+end
+
+
+
+
+function util.exists(file)
+   local fd, _, code = io.open(file, "r")
+   if code == 13 then
+
+
+      return true
+   end
+   if fd then
+      fd:close()
+      return true
+   end
+   return false
+end
+
+function util.lua_is_wrapper(interp)
+   local fd, err = io.open(interp, "r")
+   if not fd then
+      return nil, err
+   end
+   local data
+   data, err = fd:read(1000)
+   fd:close()
+   if not data then
+      return nil, err
+   end
+   return not not data:match("LUAROCKS_SYSCONFDIR")
+end
+
+do
+   local function Q(pathname)
+      if pathname:match("^.:") then
+         return pathname:sub(1, 2) .. '"' .. pathname:sub(3) .. '"'
+      end
+      return '"' .. pathname .. '"'
+   end
+
+   function util.check_lua_version(lua, luaver)
+      if not util.exists(lua) then
+         return nil
+      end
+      local lv = util.popen_read(Q(lua) .. ' -e "io.write(_VERSION:sub(5))"')
+      if lv == "" then
+         return nil
+      end
+      if luaver and luaver ~= lv then
+         return nil
+      end
+      return lv
+   end
+
+   function util.get_luajit_version()
+      if cfg.cache.luajit_version_checked then
+         return cfg.cache.luajit_version
+      end
+      cfg.cache.luajit_version_checked = true
+
+      if not cfg.variables.LUA then
+         return nil
+      end
+
+      local ljv
+      if cfg.lua_version == "5.1" then
+
+         ljv = util.popen_read(Q(cfg.variables.LUA) .. ' -e "io.write(tostring(jit and jit.version:gsub([[^%S+ (%S+).*]], [[%1]])))"')
+         if ljv == "nil" then
+            ljv = nil
+         end
+      end
+      cfg.cache.luajit_version = ljv
+      return ljv
+   end
+
+   local find_lua_bindir
+   do
+      local exe_suffix = (package.config:sub(1, 1) == "\\" and ".exe" or "")
+
+      local function insert_lua_variants(names, luaver)
+         local variants = {
+            "lua" .. luaver .. exe_suffix,
+            "lua" .. luaver:gsub("%.", "") .. exe_suffix,
+            "lua-" .. luaver .. exe_suffix,
+            "lua-" .. luaver:gsub("%.", "") .. exe_suffix,
+         }
+         for _, name in ipairs(variants) do
+            table.insert(names, name)
+         end
+      end
+
+      find_lua_bindir = function(prefix, luaver, verbose)
+         local names = {}
+         if luaver then
+            insert_lua_variants(names, luaver)
+         else
+            for v in util.lua_versions("descending") do
+               insert_lua_variants(names, v)
+            end
+         end
+         if luaver == "5.1" or not luaver then
+            table.insert(names, "luajit" .. exe_suffix)
+         end
+         table.insert(names, "lua" .. exe_suffix)
+
+         local tried = {}
+         local dir_sep = package.config:sub(1, 1)
+         for _, d in ipairs({ prefix .. dir_sep .. "bin", prefix }) do
+            for _, name in ipairs(names) do
+               local lua = d .. dir_sep .. name
+               local is_wrapper, err = util.lua_is_wrapper(lua)
+               if is_wrapper == false then
+                  local lv = util.check_lua_version(lua, luaver)
+                  if lv then
+                     return lua, d, lv
+                  end
+               elseif is_wrapper == true or err == nil then
+                  table.insert(tried, lua)
+               else
+                  table.insert(tried, string.format("%-13s (%s)", lua, err))
+               end
+            end
+         end
+         local interp = luaver and
+         ("Lua " .. luaver .. " interpreter") or
+         "Lua interpreter"
+         return nil, interp .. " not found at " .. prefix .. "\n" ..
+         (verbose and "Tried:\t" .. table.concat(tried, "\n\t") or "")
+      end
+   end
+
+   function util.find_lua(prefix, luaver, verbose)
+      local lua, bindir
+      lua, bindir, luaver = find_lua_bindir(prefix, luaver, verbose)
+      if not lua then
+         return nil, bindir
+      end
+
+      return {
+         lua_version = luaver,
+         lua = lua,
+         lua_dir = prefix,
+         lua_bindir = bindir,
+      }
+   end
+end
+
+
+
+function util.opts_table(type_name, valid_opts) --! TEMP
+   local opts_mt = {}
+
+   opts_mt.__index = opts_mt
+
+   function opts_mt.type()
+      return type_name
+   end
+
+   return function(opts)
+      for k, v in pairs(opts) do
+         local tv = type(v)
+         if not valid_opts[k] then
+            error("invalid option: "..k)
+         end
+         local vo, optional = valid_opts[k]:match("^(.-)(%??)$")
+         if not (tv == vo or (optional == "?" and tv == nil)) then
+            error("invalid type option: "..k.." - got "..tv..", expected "..vo)
+         end
+      end
+      for k, v in pairs(valid_opts) do
+         if (not v:find("?", 1, true)) and opts[k] == nil then
+            error("missing option: "..k)
+         end
+      end
+      return setmetatable(opts, opts_mt)
+   end
+end
+
+
+
+
+function util.get_rocks_provided(rockspec)
+
+   if not rockspec and cfg.cache.rocks_provided then
+      return cfg.cache.rocks_provided
+   end
+
+   local rocks_provided = {}
+
+   local lv = cfg.lua_version
+
+   rocks_provided["lua"] = lv .. "-1"
+
+   if lv == "5.2" then
+      rocks_provided["bit32"] = lv .. "-1"
+   end
+
+   if lv == "5.3" or lv == "5.4" then
+      rocks_provided["utf8"] = lv .. "-1"
+   end
+
+   if lv == "5.1" then
+      local ljv = util.get_luajit_version()
+      if ljv then
+         rocks_provided["luabitop"] = ljv .. "-1"
+         if (not rockspec) or rockspec:format_is_at_least("3.0") then
+            rocks_provided["luajit"] = ljv .. "-1"
+         end
+      end
+   end
+
+   if cfg.rocks_provided then
+      util.deep_merge_under(rocks_provided, cfg.rocks_provided)
+   end
+
+   if not rockspec then
+      cfg.cache.rocks_provided = rocks_provided
+   end
+
+   return rocks_provided
+end
+
+function util.remove_doc_dir(name, version)
+   local path = require("luarocks.path")
+   local fs = require("luarocks.fs")
+   local dir = require("luarocks.dir")
+
+   local install_dir = path.install_dir(name, version)
+   for _, f in ipairs(fs.list_dir(install_dir)) do
+      local doc_dirs = { "doc", "docs" }
+      for _, d in ipairs(doc_dirs) do
+         if f == d then
+            fs.delete(dir.path(install_dir, f))
+         end
+      end
+   end
+end
+
+return util
diff --git a/src/luarocks/util.tl b/src/luarocks/util.tl
index aa04a3f3..72b8d995 100644
--- a/src/luarocks/util.tl
+++ b/src/luarocks/util.tl
@@ -548,6 +548,7 @@ do
       }
    end
 end
+
 --- Return a table of modules that are already provided by the VM, which
 -- can be specified as dependencies without having to install an actual rock.
 -- @param rockspec (optional) a rockspec table, so that rockspec format