rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/luarocks/persist.lua

@@ -0,0 +1,173 @@
+
+--- Utility module for loading files into tables and
+-- saving tables into files.
+-- Implemented separately to avoid interdependencies,
+-- as it is used in the bootstrapping stage of the cfg module.
+module("luarocks.persist", package.seeall)
+
+local util = require("luarocks.util")
+
+--- Load a Lua file containing assignments, storing them in a table.
+-- The global environment is not propagated to the loaded file.
+-- @param filename string: the name of the file.
+-- @param tbl table or nil: if given, this table is used to store
+-- loaded values.
+-- @return table or (nil, string): a table with the file's assignments
+-- as fields, or nil and a message in case of errors.
+function load_into_table(filename, tbl)
+   assert(type(filename) == "string")
+   assert(type(tbl) == "table" or not tbl)
+
+   local result, chunk, ran, err
+   local result = tbl or {}
+   if setfenv then -- Lua 5.1
+      chunk, err = loadfile(filename)
+      if chunk then
+         setfenv(chunk, result)
+         ran, err = pcall(chunk)
+      end
+   else -- Lua 5.2
+      chunk, err = loadfile(filename, "t", result)
+      if chunk then
+         ran, err = pcall(chunk)
+      end
+   end
+   
+   if not chunk then
+      if err:sub(1,5) ~= filename:sub(1,5) then
+         return false, err
+      end
+      return nil, "Error loading file: "..err
+   end
+   if not ran then
+      return nil, "Error running file: "..err
+   end
+   return result
+end
+
+local write_table
+
+--- Write a value as Lua code, invoking write_table.
+-- This function handles only numbers, strings and tables
+-- are keys (tables are handled recursively).
+-- @param out userdata: a file object, open for writing.
+-- @param v: the value to be written.
+-- @param level number: the indentation level
+-- @param sub_order table: optional prioritization table
+-- @see write_table
+local function write_value(out, v, level, sub_order)
+   if type(v) == "table" then
+      write_table(out, v, level + 1, sub_order)
+   elseif type(v) == "string" then
+      if v:match("\n") then
+         local open, close = "[[", "]]"
+         local equals = 0
+         while v:find(open,1,true) or v:find(close,1,true) do
+            equals = equals + 1
+            local eqs = ("="):rep(equals)
+            open, close = "["..eqs.."[", "]"..eqs.."]"
+         end
+         out:write(open.."\n"..v..close)
+      else
+         out:write("\""..v:gsub("\"", "\\\"").."\"")
+      end
+   else
+      out:write(tostring(v))
+   end
+end
+
+--- Write a table as Lua code representing a table to disk
+-- (that is, in curly brackets notation).
+-- This function handles only numbers, strings and tables
+-- are keys (tables are handled recursively).
+-- @param out userdata: a file object, open for writing.
+-- @param tbl table: the table to be written.
+-- @param level number: the indentation level
+-- @param field_order table: optional prioritization table
+write_table = function(out, tbl, level, field_order)
+   out:write("{")
+   local sep = "\n"
+   local indentation = "   "
+   local indent = true
+   local i = 1
+   for k, v, sub_order in util.sortedpairs(tbl, field_order) do
+      out:write(sep)
+      if indent then
+         for n = 1,level do out:write(indentation) end
+      end
+      sep = ",\n"
+      indent = true
+      if type(k) == "number" then
+         if k ~= i then
+            out:write("["..tostring(k).."]=")
+         else
+            i = i + 1
+         end
+         indent = false
+         sep = ", "
+      elseif type(k) == "table" then
+         out:write("[")
+         write_table(out, k, level + 1)
+         out:write("] = ")
+      else
+         if k:match("^[a-zA-Z_][a-zA-Z0-9_]*$") then
+            out:write(k.." = ")
+         else
+            out:write("['"..k:gsub("'", "\\'").."'] = ") 
+         end
+      end
+      write_value(out, v, level, sub_order)
+   end
+   if sep ~= "\n" then
+      out:write("\n")
+      for n = 1,level-1 do out:write(indentation) end
+   end
+   out:write("}")
+end
+
+--- Writes a table to an io-like object.
+-- @param out userdata: a file object, open for writing.
+-- @param tbl table: the table to be written.
+-- @param field_order table: optional prioritization table
+-- @return userdata The file object originally passed in as the `out` parameter.
+local function write_table(out, tbl, field_order)
+   for k, v, sub_order in util.sortedpairs(tbl, field_order) do
+      out:write(k.." = ")
+      write_value(out, v, 0, sub_order)
+      out:write("\n")
+   end
+   return out
+end
+
+--- Save the contents of a table to a string.
+-- Each element of the table is saved as a global assignment.
+-- Only numbers, strings and tables (containing numbers, strings
+-- or other recursively processed tables) are supported.
+-- @param tbl table: the table containing the data to be written
+-- @param field_order table: an optional array indicating the order of top-level fields.
+-- @return string
+function save_from_table_to_string(tbl, field_order)
+   local out = {buffer = {}}
+   function out:write(data) table.insert(self.buffer, data) end
+   write_table(out, tbl, field_order)
+   return table.concat(out.buffer)
+end
+
+--- Save the contents of a table in a file.
+-- Each element of the table is saved as a global assignment.
+-- Only numbers, strings and tables (containing numbers, strings
+-- or other recursively processed tables) are supported.
+-- @param filename string: the output filename
+-- @param tbl table: the table containing the data to be written
+-- @param field_order table: an optional array indicating the order of top-level fields.
+-- @return boolean or (nil, string): true if successful, or nil and a
+-- message in case of errors.
+function save_from_table(filename, tbl, field_order)
+   local out = io.open(filename, "w")
+   if not out then
+      return nil, "Cannot create file at "..filename
+   end
+   write_table(out, tbl, field_order)
+   out:close()
+   return true
+end

data/vendor/lua/lib/lua/luarocks/refresh_cache.lua

@@ -0,0 +1,30 @@
+
+--- Module implementing the luarocks-admin "refresh_cache" command.
+module("luarocks.refresh_cache", package.seeall)
+
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+local cache = require("luarocks.cache")
+
+help_summary = "Refresh local cache of a remote rocks server."
+help_arguments = "[--from=<server>]"
+help = [[
+The flag --from indicates which server to use.
+If not given, the default server set in the upload_server variable
+from the configuration file is used instead.
+]]
+
+function run(...)
+   local flags = util.parse_flags(...)
+   local server, upload_server = cache.get_upload_server(flags["server"])
+   if not server then return nil, upload_server end
+   local download_url = cache.get_server_urls(server, upload_server)
+   
+   local ok, err = cache.refresh_local_cache(server, download_url, cfg.upload_user, cfg.upload_password)
+   if not ok then
+      return nil, err
+   else
+      return true
+   end
+end
+

data/vendor/lua/lib/lua/luarocks/remove.lua

@@ -0,0 +1,135 @@
+
+--- Module implementing the LuaRocks "remove" command.
+-- Uninstalls rocks.
+module("luarocks.remove", package.seeall)
+
+local search = require("luarocks.search")
+local deps = require("luarocks.deps")
+local fetch = require("luarocks.fetch")
+local rep = require("luarocks.rep")
+local path = require("luarocks.path")
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+local manif = require("luarocks.manif")
+local fs = require("luarocks.fs")
+
+help_summary = "Uninstall a rock."
+help_arguments = "[--force] <name> [<version>]"
+help = [[
+Argument is the name of a rock to be uninstalled.
+If a version is not given, try to remove all versions at once.
+Will only perform the removal if it does not break dependencies.
+To override this check and force the removal, use --force.
+]]
+
+--- Obtain a list of packages that depend on the given set of packages
+-- (where all packages of the set are versions of one program).
+-- @param name string: the name of a program
+-- @param versions array of string: the versions to be deleted.
+-- @return array of string: an empty table if no packages depend on any
+-- of the given list, or an array of strings in "name/version" format.
+local function check_dependents(name, versions)
+   local dependents = {}
+   local blacklist = {}
+   blacklist[name] = {}
+   for version, _ in pairs(versions) do
+      blacklist[name][version] = true
+   end
+   local local_rocks = {}
+   local query_all = search.make_query("")
+   query_all.exact_name = false
+   search.manifest_search(local_rocks, cfg.rocks_dir, query_all)
+   local_rocks[name] = nil
+   for rock_name, rock_versions in pairs(local_rocks) do
+      for rock_version, _ in pairs(rock_versions) do
+         local rockspec, err = fetch.load_rockspec(path.rockspec_file(rock_name, rock_version))
+         if rockspec then
+            local _, missing = deps.match_deps(rockspec, blacklist)
+            if missing[name] then
+               table.insert(dependents, { name = rock_name, version = rock_version })
+            end
+         end
+      end
+   end
+   return dependents
+end
+
+--- Delete given versions of a program.
+-- @param name string: the name of a program
+-- @param versions array of string: the versions to be deleted.
+-- @return boolean or (nil, string): true on success or nil and an error message.
+local function delete_versions(name, versions) 
+
+   for version, _ in pairs(versions) do
+      util.printout("Removing "..name.." "..version.."...")
+      local ok, err = rep.delete_version(name, version)
+      if not ok then return nil, err end
+   end
+   
+   return true
+end
+
+--- Driver function for the "remove" command.
+-- @param name string: name of a rock. If a version is given, refer to
+-- a specific version; otherwise, try to remove all versions.
+-- @param version string: When passing a package name, a version number
+-- may also be given.
+-- @return boolean or (nil, string): True if removal was
+-- successful, nil and an error message otherwise.
+function run(...)
+   local flags, name, version = util.parse_flags(...)
+   
+   if type(name) ~= "string" then
+      return nil, "Argument missing, see help."
+   end
+   
+   local ok, err = fs.check_command_permissions(flags)
+   if not ok then return nil, err end
+
+   local results = {}
+   search.manifest_search(results, cfg.rocks_dir, search.make_query(name, version))
+
+   local versions = results[name]
+   if not versions then
+      return nil, "Could not find rock '"..name..(version and " "..version or "").."' in local tree."
+   else
+      local version = next(versions)
+      local second = next(versions, version)
+      
+      util.printout("Checking stability of dependencies on the absence of")
+      util.printout(name.." "..table.concat(util.keys(versions), ", ").."...")
+      util.printout()
+      
+      local dependents = check_dependents(name, versions)
+      
+      if #dependents == 0 or flags["force"] then
+         if #dependents > 0 then
+            util.printerr("The following packages may be broken by this forced removal:")
+            for _, dependent in ipairs(dependents) do
+               util.printerr(dependent.name.." "..dependent.version)
+            end
+            util.printerr()
+         end
+         local ok, err = delete_versions(name, versions)
+         if not ok then return nil, err end
+         ok, err = manif.make_manifest(cfg.rocks_dir)
+         if not ok then return nil, err end
+      else
+         if not second then
+            util.printerr("Will not remove "..name.." "..version..".")
+            util.printerr("Removing it would break dependencies for: ")
+         else
+            util.printerr("Will not remove all versions of "..name..".")
+            util.printerr("Removing them would break dependencies for: ")
+         end
+         for _, dependent in ipairs(dependents) do
+            util.printerr(dependent.name.." "..dependent.version)
+         end
+         util.printerr()
+         util.printerr("Use --force to force removal (warning: this may break modules).")
+         return nil, "Failed removing."
+      end
+   end
+   util.printout("Removal successful.")
+   return true
+end

data/vendor/lua/lib/lua/luarocks/rep.lua

@@ -0,0 +1,313 @@
+
+--- Functions for managing the repository on disk.
+module("luarocks.rep", package.seeall)
+
+local fs = require("luarocks.fs")
+local path = require("luarocks.path")
+local cfg = require("luarocks.cfg")
+local util = require("luarocks.util")
+local dir = require("luarocks.dir")
+local manif = require("luarocks.manif")
+local deps = require("luarocks.deps")
+
+--- Get all installed versions of a package.
+-- @param name string: a package name.
+-- @return table or nil: An array of strings listing installed
+-- versions of a package, or nil if none is available.
+function get_versions(name)
+   assert(type(name) == "string")
+   
+   local dirs = fs.list_dir(path.versions_dir(name))
+   return (dirs and #dirs > 0) and dirs or nil
+end
+
+--- Check if a package exists in a local repository.
+-- Version numbers are compared as exact string comparison.
+-- @param name string: name of package
+-- @param version string: package version in string format
+-- @return boolean: true if a package is installed,
+-- false otherwise.
+function is_installed(name, version)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+      
+   return fs.is_dir(path.install_dir(name, version))
+end
+
+local function recurse_rock_manifest_tree(file_tree, action) 
+   assert(type(file_tree) == "table")
+   assert(type(action) == "function")
+   local function do_recurse_rock_manifest_tree(tree, parent_path, parent_module)
+      
+      for file, sub in pairs(tree) do
+         if type(sub) == "table" then
+            local ok, err = do_recurse_rock_manifest_tree(sub, parent_path..file.."/", parent_module..file..".")
+            if not ok then return nil, err end
+         else
+            local ok, err = action(parent_path, parent_module, file)
+            if not ok then return nil, err end
+         end
+      end
+      return true
+   end
+   return do_recurse_rock_manifest_tree(file_tree, "", "")
+end
+
+local function store_package_data(result, name, sub, prefix)
+   assert(type(result) == "table")
+   assert(type(name) == "string")
+   assert(type(sub) == "table" or type(sub) == "string")
+   assert(type(prefix) == "string")
+
+   if type(sub) == "table" then
+      for sname, ssub in pairs(sub) do
+         store_package_data(result, sname, ssub, prefix..name.."/")
+      end
+   elseif type(sub) == "string" then
+      local pathname = prefix..name
+      result[path.path_to_module(pathname)] = pathname
+   end
+end
+
+local function store_package_data(result, name, file_tree)
+   if not file_tree then return end
+   return recurse_rock_manifest_tree(file_tree, 
+      function(parent_path, parent_module, file)
+         local pathname = parent_path..file
+         result[path.path_to_module(pathname)] = pathname
+         return true
+      end
+   )
+end
+
+--- Obtain a list of modules within an installed package.
+-- @param package string: The package name; for example "luasocket"
+-- @param version string: The exact version number including revision;
+-- for example "2.0.1-1".
+-- @return table: A table of modules where keys are module identifiers
+-- in "foo.bar" format and values are pathnames in architecture-dependent
+-- "foo/bar.so" format. If no modules are found or if package or version
+-- are invalid, an empty table is returned.
+function package_modules(package, version)
+   assert(type(package) == "string")
+   assert(type(version) == "string")
+
+   local result = {}
+   local rock_manifest = manif.load_rock_manifest(package, version)
+   store_package_data(result, package, rock_manifest.lib)
+   store_package_data(result, package, rock_manifest.lua)
+   return result
+end
+
+--- Obtain a list of command-line scripts within an installed package.
+-- @param package string: The package name; for example "luasocket"
+-- @param version string: The exact version number including revision;
+-- for example "2.0.1-1".
+-- @return table: A table of items where keys are command names
+-- as strings and values are pathnames in architecture-dependent
+-- ".../bin/foo" format. If no modules are found or if package or version
+-- are invalid, an empty table is returned.
+function package_commands(package, version)
+   assert(type(package) == "string")
+   assert(type(version) == "string")
+
+   local result = {}
+   local rock_manifest = manif.load_rock_manifest(package, version)
+   store_package_data(result, package, rock_manifest.bin)
+   return result
+end
+
+
+--- Check if a rock contains binary executables.
+-- @param name string: name of an installed rock
+-- @param version string: version of an installed rock
+-- @return boolean: returns true if rock contains platform-specific
+-- binary executables, or false if it is a pure-Lua rock.
+function has_binaries(name, version)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+
+   local rock_manifest = manif.load_rock_manifest(name, version)
+   if rock_manifest.bin then
+      for name, md5 in pairs(rock_manifest.bin) do
+         -- TODO verify that it is the same file. If it isn't, find the actual command.
+         if fs.is_actual_binary(dir.path(cfg.deploy_bin_dir, name)) then
+            return true
+         end
+      end
+   end
+   return false
+end
+
+function run_hook(rockspec, hook_name)
+   assert(type(rockspec) == "table")
+   assert(type(hook_name) == "string")
+
+   local hooks = rockspec.hooks
+   if not hooks then
+      return true
+   end
+   if not hooks.substituted_variables then
+      util.variable_substitutions(hooks, rockspec.variables)
+      hooks.substituted_variables = true
+   end
+   local hook = hooks[hook_name]
+   if hook then
+      util.printout(hook)
+      if not fs.execute(hook) then
+         return nil, "Failed running "..hook_name.." hook."
+      end
+   end
+   return true
+end
+
+local function install_binary(source, target)
+   assert(type(source) == "string")
+   assert(type(target) == "string")
+
+   local match = source:match("%.lua$")
+   local file, ok, err
+   if not match then
+      file = io.open(source)
+   end
+   if match or (file and file:read():match("^#!.*lua.*")) then
+      ok, err = fs.wrap_script(source, target)
+   else
+      ok, err = fs.copy_binary(source, target)
+   end
+   if file then file:close() end
+   return ok, err
+end
+
+local function resolve_conflict(target, deploy_dir, name, version)
+   local cname, cversion = manif.find_current_provider(target)
+   if not cname then
+      return nil, cversion
+   end
+   if name ~= cname or deps.compare_versions(version, cversion) then
+      local versioned = path.versioned_name(target, deploy_dir, cname, cversion)
+      fs.make_dir(dir.dir_name(versioned))
+      fs.move(target, versioned)
+      return target
+   else
+      return path.versioned_name(target, deploy_dir, name, version)
+   end
+end
+
+function should_wrap_bin_scripts(rockspec)
+   assert(type(rockspec) == "table")
+
+   if cfg.wrap_bin_scripts ~= nil then
+      return cfg.wrap_bin_scripts
+   end
+   if rockspec.deploy and rockspec.deploy.wrap_bin_scripts == false then
+      return false
+   end
+   return true
+end
+
+function deploy_files(name, version, wrap_bin_scripts)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(type(wrap_bin_scripts) == "boolean")
+
+   local function deploy_file_tree(file_tree, source_dir, deploy_dir, move_fn)
+      if not move_fn then
+         move_fn = fs.move
+      end
+      return recurse_rock_manifest_tree(file_tree, 
+         function(parent_path, parent_module, file)
+            local source = dir.path(source_dir, parent_path, file)
+            local target = dir.path(deploy_dir, parent_path, file)
+            local ok, err
+            if fs.exists(target) then
+               local new_target, err = resolve_conflict(target, deploy_dir, name, version)
+               if err == "untracked" then
+                  fs.delete(target)
+               elseif err then
+                  return nil, err.." Cannot install new version."
+               else
+                  target = new_target
+               end
+	    end
+            fs.make_dir(dir.dir_name(target))
+            ok, err = move_fn(source, target)
+            fs.remove_dir_tree_if_empty(dir.dir_name(source))
+            if not ok then return nil, err end
+            return true
+         end
+      )
+   end
+
+   local rock_manifest = manif.load_rock_manifest(name, version)
+   
+   local ok, err = true
+   if rock_manifest.bin then
+      local move_bin_fn = wrap_bin_scripts and install_binary or fs.copy_binary
+      ok, err = deploy_file_tree(rock_manifest.bin, path.bin_dir(name, version), cfg.deploy_bin_dir, move_bin_fn)
+   end
+   if ok and rock_manifest.lua then
+      ok, err = deploy_file_tree(rock_manifest.lua, path.lua_dir(name, version), cfg.deploy_lua_dir)
+   end
+   if ok and rock_manifest.lib then
+      ok, err = deploy_file_tree(rock_manifest.lib, path.lib_dir(name, version), cfg.deploy_lib_dir)
+   end
+   return ok, err
+end
+
+--- Delete a package from the local repository.
+-- Version numbers are compared as exact string comparison.
+-- @param name string: name of package
+-- @param version string: package version in string format
+function delete_version(name, version)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+
+   local function delete_deployed_file_tree(file_tree, deploy_dir)
+      return recurse_rock_manifest_tree(file_tree, 
+         function(parent_path, parent_module, file)
+            local target = dir.path(deploy_dir, parent_path, file)
+            local versioned = path.versioned_name(target, deploy_dir, name, version)
+            if fs.exists(versioned) then
+               local ok = fs.delete(versioned)
+               fs.remove_dir_tree_if_empty(dir.dir_name(versioned))
+               if not ok then return nil, "Failed deleting "..versioned end
+            else
+               local ok = fs.delete(target)
+               local next_name, next_version = manif.find_next_provider(target)
+               if next_name then
+                  local versioned = path.versioned_name(target, deploy_dir, next_name, next_version)
+                  fs.move(versioned, target)
+                  fs.remove_dir_tree_if_empty(dir.dir_name(versioned))
+               end
+               fs.remove_dir_tree_if_empty(dir.dir_name(target))
+               if not ok then return nil, "Failed deleting "..target end
+            end
+            return true
+         end
+      )
+   end
+
+   local rock_manifest = manif.load_rock_manifest(name, version)
+   if not rock_manifest then
+      return nil, "rock_manifest file not found for "..name.." "..version.." - not a LuaRocks 2 tree?"
+   end
+   
+   local ok, err = true
+   if rock_manifest.bin then
+      ok, err = delete_deployed_file_tree(rock_manifest.bin, cfg.deploy_bin_dir)
+   end
+   if ok and rock_manifest.lua then
+      ok, err = delete_deployed_file_tree(rock_manifest.lua, cfg.deploy_lua_dir)
+   end
+   if ok and rock_manifest.lib then
+      ok, err = delete_deployed_file_tree(rock_manifest.lib, cfg.deploy_lib_dir)
+   end
+   if err then return nil, err end
+
+   fs.delete(path.install_dir(name, version))
+   if not get_versions(name) then
+      fs.delete(dir.path(cfg.rocks_dir, name))
+   end
+   return true
+end