rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/luarocks/new_version.lua

@@ -0,0 +1,141 @@
+
+--- Module implementing the LuaRocks "new_version" command.
+-- Utility function that writes a new rockspec, updating data from a previous one.
+module("luarocks.new_version", package.seeall)
+
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+local download = require("luarocks.download")
+local fetch = require("luarocks.fetch")
+local persist = require("luarocks.persist")
+local dir = require("luarocks.dir")
+local fs = require("luarocks.fs")
+
+help_summary = "Auto-write a rockspec for a new version of a rock."
+help_arguments = "{<program>|<rockspec>} [<new_version>] [<new_url>]"
+help = [[
+This is a utility function that writes a new rockspec, updating data
+from a previous one.
+
+If a package name is given, it downloads the latest rockspec from the
+default server. If a rockspec is given, it uses it instead.
+
+If the version number is not given, it only increments the revision
+number of the given (or downloaded) rockspec.
+
+If a URL is given, it replaces the one from the old rockspec with the
+given URL. If a URL is not given and a new version is given, it tries
+to guess the new URL by replacing occurrences of the version number
+in the URL or tag. It also tries to download the new URL to determine
+the new MD5 checksum.
+
+WARNING: it writes the new rockspec to the current directory,
+overwriting the file if it already exists.
+]]
+
+local order = {"rockspec_format", "package", "version", 
+   { "source", { "url", "tag", "branch", "md5" } },
+   { "description", {"summary", "detailed", "homepage", "license" } },
+   "supported_platforms", "dependencies", "external_dependencies",
+   { "build", {"type", "modules", "copy_directories", "platforms"} },
+   "hooks"}
+
+local function try_replace(tbl, field, old, new)
+   if not tbl[field] then
+      return false
+   end
+   local old_field = tbl[field]
+   local new_field = tbl[field]:gsub(old, new)
+   if new_field ~= old_field then
+      util.printout("Guessing new '"..field.."' field as "..new_field)
+      tbl[field] = new_field
+      return true      
+   end
+   return false
+end
+
+local function check_url_and_update_md5(out_rs, out_name)
+   out_rs.source.md5 = nil
+   local file, temp_dir = fetch.fetch_url_at_temp_dir(out_rs.source.url, "luarocks-new-version-"..out_name)
+   if file then
+      util.printout("File successfully downloaded. Updating MD5 checksum...")
+      out_rs.source.md5 = fs.get_md5(file)
+   else
+      util.printerr("Warning: invalid URL - "..temp_dir)
+   end
+end
+ 
+function run(...)
+   local flags, input, version, url = util.parse_flags(...)
+   if not input then
+      return nil, "Missing arguments: expected program or rockspec. See help."
+   end
+   assert(type(input) == "string")
+   
+   local filename = input
+   if not input:match(".rockspec$") then
+      local err
+      filename, err = download.download("rockspec", input)
+      if not input then
+         return nil, err
+      end
+   end
+   
+   local valid_rs, err = fetch.load_rockspec(filename)
+   if not valid_rs then
+      return nil, err
+   end
+
+   local old_ver, old_rev = valid_rs.version:match("(.*)%-(%d+)$")
+   local new_ver, new_rev
+   
+   if version then
+      new_ver, new_rev = version:match("(.*)%-(%d+)$")
+      new_rev = tonumber(new_rev)
+      if not new_rev then
+         new_ver = version
+         new_rev = 1
+      end
+   else
+      new_ver = old_ver
+      new_rev = tonumber(old_rev) + 1
+   end
+   
+   
+   local out_rs = persist.load_into_table(filename)
+   local out_name = out_rs.package:lower()
+   out_rs.version = new_ver.."-"..new_rev
+   if url then
+      out_rs.source.url = url
+      check_url_and_update_md5(out_rs, out_name)
+   else
+      if new_ver ~= old_ver then
+         local ok = try_replace(out_rs.source, "url", old_ver, new_ver)
+         if ok then
+            check_url_and_update_md5(out_rs, out_name)
+         else
+            ok = try_replace(out_rs.source, "tag", old_ver, new_ver)
+            if not ok then
+               return nil, "Failed to determine the location of the new version."
+            end
+         end
+      end
+   end
+   
+   if out_rs.build and out_rs.build.type == "module" then
+      out_rs.build.type = "builtin"
+   end
+   
+   local out_filename = out_name.."-"..new_ver.."-"..new_rev..".rockspec"
+   
+   persist.save_from_table(out_filename, out_rs, order)
+   
+   util.printout("Wrote "..out_filename)
+
+   local valid_out_rs, err = fetch.load_local_rockspec(out_filename)
+   if not valid_out_rs then
+      return nil, "Failed loading generated rockspec: "..err
+   end
+   
+   return true
+end

data/vendor/lua/lib/lua/luarocks/pack.lua

@@ -0,0 +1,205 @@
+
+--- Module implementing the LuaRocks "pack" command.
+-- Creates a rock, packing sources or binaries.
+module("luarocks.pack", package.seeall)
+
+local path = require("luarocks.path")
+local rep = require("luarocks.rep")
+local fetch = require("luarocks.fetch")
+local fs = require("luarocks.fs")
+local cfg = require("luarocks.cfg")
+local util = require("luarocks.util")
+local dir = require("luarocks.dir")
+local manif = require("luarocks.manif")
+local search = require("luarocks.search")
+
+help_summary = "Create a rock, packing sources or binaries."
+help_arguments = "{<rockspec>|<name> [<version>]}"
+help = [[
+Argument may be a rockspec file, for creating a source rock,
+or the name of an installed package, for creating a binary rock.
+In the latter case, the app version may be given as a second
+argument.
+]]
+
+--- Create a source rock.
+-- Packages a rockspec and its required source files in a rock
+-- file with the .src.rock extension, which can later be built and
+-- installed with the "build" command.
+-- @param rockspec_file string: An URL or pathname for a rockspec file.
+-- @return string or (nil, string): The filename of the resulting
+-- .src.rock file; or nil and an error message.
+local function pack_source_rock(rockspec_file)
+   assert(type(rockspec_file) == "string")
+
+   local rockspec, err = fetch.load_rockspec(rockspec_file)
+   if err then
+      return nil, "Error loading rockspec: "..err
+   end
+   rockspec_file = rockspec.local_filename
+
+   local name_version = rockspec.name .. "-" .. rockspec.version
+   local rock_file = fs.absolute_name(name_version .. ".src.rock")
+
+   local source_file, source_dir = fetch.fetch_sources(rockspec, false)
+   if not source_file then
+      return nil, source_dir
+   end
+   fs.change_dir(source_dir)
+
+   fs.delete(rock_file)
+   fs.copy(rockspec_file, source_dir)
+   if not fs.zip(rock_file, dir.base_name(rockspec_file), dir.base_name(source_file)) then
+      return nil, "Failed packing "..rock_file
+   end
+   fs.pop_dir()
+
+   return rock_file
+end
+
+local function copy_back_files(name, version, file_tree, deploy_dir, pack_dir)
+   fs.make_dir(pack_dir)
+   for file, sub in pairs(file_tree) do
+      local source = dir.path(deploy_dir, file)
+      local target = dir.path(pack_dir, file)
+      if type(sub) == "table" then
+         local ok, err = copy_back_files(name, version, sub, source, target)
+      else
+         local versioned = path.versioned_name(source, deploy_dir, name, version)
+         if fs.exists(versioned) then
+            fs.copy(versioned, target)
+         else
+            fs.copy(source, target)
+         end
+      end
+   end
+   return true
+end
+
+-- @param name string: Name of package to pack.
+-- @param version string or nil: A version number may also be passed.
+-- @return string or (nil, string): The filename of the resulting
+-- .src.rock file; or nil and an error message.
+local function do_pack_binary_rock(name, version)
+   assert(type(name) == "string")
+   assert(type(version) == "string" or not version)
+
+   local query = search.make_query(name, version)
+   query.exact_name = true
+   local results = {}
+   
+   search.manifest_search(results, cfg.rocks_dir, query)
+   
+   if not next(results) then
+      return nil, "'"..name.."' does not seem to be an installed rock."
+   end
+   
+   local versions = results[name]
+   
+   if not version then
+      local first = next(versions)
+      if next(versions, first) then
+         return nil, "Please specify which version of '"..name.."' to pack."
+      end
+      version = first
+   end
+   if not version:match("[^-]+%-%d+") then
+      return nil, "Expected version "..version.." in version-revision format."
+   end
+   
+   local info = versions[version][1]
+   
+   local root = path.root_dir(info.repo)
+   local prefix = path.install_dir(name, version, root)
+   
+   if not fs.exists(prefix) then
+      return nil, "'"..name.." "..version.."' does not seem to be an installed rock."
+   end
+   
+   local rock_manifest = manif.load_rock_manifest(name, version, root)
+   if not rock_manifest then
+      return nil, "rock_manifest file not found for "..name.." "..version.." - not a LuaRocks 2 tree?"
+   end
+
+   local name_version = name .. "-" .. version
+   local rock_file = fs.absolute_name(name_version .. "."..cfg.arch..".rock")
+   
+   local temp_dir = fs.make_temp_dir("pack")
+   fs.copy_contents(prefix, temp_dir)
+
+   local is_binary = false
+   if rock_manifest.lib then
+      copy_back_files(name, version, rock_manifest.lib, path.deploy_lib_dir(root), dir.path(temp_dir, "lib"))
+      is_binary = true
+   end
+   if rock_manifest.lua then
+      copy_back_files(name, version, rock_manifest.lua, path.deploy_lua_dir(root), dir.path(temp_dir, "lua"))
+   end
+   
+   fs.change_dir(temp_dir)
+   if not is_binary and not rep.has_binaries(name, version) then
+      rock_file = rock_file:gsub("%."..cfg.arch:gsub("%-","%%-").."%.", ".all.")
+   end
+   fs.delete(rock_file)
+   if not fs.zip(rock_file, unpack(fs.list_dir())) then
+      return nil, "Failed packing "..rock_file
+   end
+   fs.pop_dir()
+   fs.delete(temp_dir)
+   return rock_file
+end
+
+function pack_binary_rock(name, version, cmd, ...)
+
+   -- The --pack-binary-rock option for "luarocks build" basically performs
+   -- "luarocks build" on a temporary tree and then "luarocks pack". The
+   -- alternative would require refactoring parts of luarocks.build and
+   -- luarocks.pack, which would save a few file operations: the idea would be
+   -- to shave off the final deploy steps from the build phase and the initial
+   -- collect steps from the pack phase.
+
+   local temp_dir = fs.make_temp_dir("luarocks-build-pack-"..dir.base_name(name))
+   if not temp_dir then
+      return nil, "Failed creating temporary directory."
+   end
+   util.schedule_function(fs.delete, temp_dir)
+
+   path.use_tree(temp_dir)
+   local ok, err = cmd(...)
+   if not ok then
+      return nil, err
+   end
+   local rname, rversion = path.parse_name(name)
+   if not rname then
+      rname, rversion = name, version
+   end
+   return do_pack_binary_rock(rname, rversion)
+end
+
+--- Driver function for the "pack" command.
+-- @param arg string:  may be a rockspec file, for creating a source rock,
+-- or the name of an installed package, for creating a binary rock.
+-- @param version string or nil: if the name of a package is given, a
+-- version may also be passed.
+-- @return boolean or (nil, string): true if successful or nil followed
+-- by an error message.
+function run(...)
+   local flags, arg, version = util.parse_flags(...)
+   assert(type(version) == "string" or not version)
+   if type(arg) ~= "string" then
+      return nil, "Argument missing, see help."
+   end
+
+   local file, err
+   if arg:match(".*%.rockspec") then
+      file, err = pack_source_rock(arg)
+   else
+      file, err = do_pack_binary_rock(arg, version)
+   end
+   if err then
+      return nil, err
+   else
+      util.printout("Packed: "..file)
+      return true
+   end
+end

data/vendor/lua/lib/lua/luarocks/path.lua

@@ -0,0 +1,315 @@
+
+--- LuaRocks-specific path handling functions.
+-- All paths are configured in this module, making it a single
+-- point where the layout of the local installation is defined in LuaRocks.
+module("luarocks.path", package.seeall)
+
+local dir = require("luarocks.dir")
+local cfg = require("luarocks.cfg")
+local util = require("luarocks.util")
+
+help_summary = "Return the currently configured package path."
+help_arguments = ""
+help = [[
+Returns the package path currently configured for this installation
+of LuaRocks, formatted as shell commands to update LUA_PATH and
+LUA_CPATH. (On Unix systems, you may run: eval `luarocks path`)
+]]
+
+--- Infer rockspec filename from a rock filename.
+-- @param rock_name string: Pathname of a rock file.
+-- @return string: Filename of the rockspec, without path.
+function rockspec_name_from_rock(rock_name)
+   assert(type(rock_name) == "string")
+   local base_name = dir.base_name(rock_name)
+   return base_name:match("(.*)%.[^.]*.rock") .. ".rockspec"
+end
+
+function rocks_dir(tree)
+   if type(tree) == "string" then
+      return dir.path(tree, "lib", "luarocks", "rocks")
+   else
+      assert(type(tree) == "table")
+      return tree.rocks_dir or dir.path(tree.root, "lib", "luarocks", "rocks")
+   end
+end
+
+function root_dir(rocks_dir)
+   assert(type(rocks_dir) == "string")
+   
+   local suffix = dir.path("lib", "luarocks", "rocks")
+   return rocks_dir:match("(.*)" .. suffix .. "$")
+end
+
+function deploy_bin_dir(tree)
+   if type(tree) == "string" then
+      return dir.path(tree, "bin")
+   else
+      assert(type(tree) == "table")
+      return tree.bin_dir or dir.path(tree.root, "bin")
+   end
+end
+
+function deploy_lua_dir(tree)
+   if type(tree) == "string" then
+      return dir.path(tree, cfg.lua_modules_path)
+   else
+      assert(type(tree) == "table")
+      return tree.lua_dir or dir.path(tree.root, cfg.lua_modules_path)
+   end
+end
+
+function deploy_lib_dir(tree)
+   if type(tree) == "string" then
+      return dir.path(tree, cfg.lib_modules_path)
+   else
+      assert(type(tree) == "table")
+      return tree.lib_dir or dir.path(tree.root, cfg.lib_modules_path)
+   end
+end
+
+function manifest_file(tree)
+   if type(tree) == "string" then
+      return dir.path(tree, "lib", "luarocks", "rocks", "manifest")
+   else
+      assert(type(tree) == "table")
+      return (tree.rocks_dir and dir.path(tree.rocks_dir, "manifest")) or dir.path(tree.root, "lib", "luarocks", "rocks", "manifest")
+   end
+end
+
+--- Get the directory for all versions of a package in a tree.
+-- @param name string: The package name. 
+-- @return string: The resulting path -- does not guarantee that
+-- @param tree string or nil: If given, specifies the local tree to use.
+-- the package (and by extension, the path) exists.
+function versions_dir(name, tree)
+   assert(type(name) == "string")
+   tree = tree or cfg.root_dir
+   return dir.path(rocks_dir(tree), name)
+end
+
+--- Get the local installation directory (prefix) for a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param tree string or nil: If given, specifies the local tree to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function install_dir(name, version, tree)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   tree = tree or cfg.root_dir
+   return dir.path(rocks_dir(tree), name, version)
+end
+
+--- Get the local filename of the rockspec of an installed rock.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param tree string or nil: If given, specifies the local tree to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the file) exists.
+function rockspec_file(name, version, tree)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   tree = tree or cfg.root_dir
+   return dir.path(rocks_dir(tree), name, version, name.."-"..version..".rockspec")
+end
+
+--- Get the local filename of the rock_manifest file of an installed rock.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param tree string or nil: If given, specifies the local tree to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the file) exists.
+function rock_manifest_file(name, version, tree)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   tree = tree or cfg.root_dir
+   return dir.path(rocks_dir(tree), name, version, "rock_manifest")
+end
+
+--- Get the local installation directory for C libraries of a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param tree string or nil: If given, specifies the local tree to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function lib_dir(name, version, tree)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   tree = tree or cfg.root_dir
+   return dir.path(rocks_dir(tree), name, version, "lib")
+end
+
+--- Get the local installation directory for Lua modules of a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param tree string or nil: If given, specifies the local tree to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function lua_dir(name, version, tree)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   tree = tree or cfg.root_dir
+   return dir.path(rocks_dir(tree), name, version, "lua")
+end
+
+--- Get the local installation directory for documentation of a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param tree string or nil: If given, specifies the local tree to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function doc_dir(name, version, tree)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   tree = tree or cfg.root_dir
+   return dir.path(rocks_dir(tree), name, version, "doc")
+end
+
+--- Get the local installation directory for configuration files of a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param tree string or nil: If given, specifies the local tree to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function conf_dir(name, version, tree)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   tree = tree or cfg.root_dir
+   return dir.path(rocks_dir(tree), name, version, "conf")
+end
+
+--- Get the local installation directory for command-line scripts
+-- of a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param tree string or nil: If given, specifies the local tree to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function bin_dir(name, version, tree)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   tree = tree or cfg.root_dir
+   return dir.path(rocks_dir(tree), name, version, "bin")
+end
+
+--- Extract name, version and arch of a rock filename,
+-- or name, version and "rockspec" from a rockspec name.
+-- @param file_name string: pathname of a rock or rockspec
+-- @return (string, string, string) or nil: name, version and arch
+-- or nil if name could not be parsed
+function parse_name(file_name)
+   assert(type(file_name) == "string")
+   if file_name:match("%.rock$") then
+      return dir.base_name(file_name):match("(.*)-([^-]+-%d+)%.([^.]+)%.rock$")
+   else
+      return dir.base_name(file_name):match("(.*)-([^-]+-%d+)%.(rockspec)")
+   end
+end
+
+--- Make a rockspec or rock URL.
+-- @param pathname string: Base URL or pathname.
+-- @param name string: Package name.
+-- @param version string: Package version.
+-- @param arch string: Architecture identifier, or "rockspec" or "installed".
+-- @return string: A URL or pathname following LuaRocks naming conventions.
+function make_url(pathname, name, version, arch)
+   assert(type(pathname) == "string")
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(type(arch) == "string")
+
+   local filename = name.."-"..version
+   if arch == "installed" then
+      filename = dir.path(name, version, filename..".rockspec")
+   elseif arch == "rockspec" then
+      filename = filename..".rockspec"
+   else
+      filename = filename.."."..arch..".rock"
+   end
+   return dir.path(pathname, filename)
+end
+
+--- Convert a pathname to a module identifier.
+-- In Unix, for example, a path "foo/bar/baz.lua" is converted to
+-- "foo.bar.baz"; "bla/init.lua" returns "bla"; "foo.so" returns "foo".
+-- @param file string: Pathname of module
+-- @return string: The module identifier, or nil if given path is
+-- not a conformant module path (the function does not check if the
+-- path actually exists).
+function path_to_module(file)
+   assert(type(file) == "string")
+
+   local name = file:match("(.*)%."..cfg.lua_extension.."$")
+   if name then
+      name = name:gsub(dir.separator, ".")
+      local init = name:match("(.*)%.init$")
+      if init then
+         name = init
+      end
+   else
+      name = file:match("(.*)%."..cfg.lib_extension.."$")
+      if name then
+         name = name:gsub(dir.separator, ".")
+      end
+   end
+   if not name then name = file end
+   name = name:gsub("^%.+", ""):gsub("%.+$", "")
+   return name
+end
+
+--- Obtain the directory name where a module should be stored.
+-- For example, on Unix, "foo.bar.baz" will return "foo/bar".
+-- @param mod string: A module name in Lua dot-separated format.
+-- @return string: A directory name using the platform's separator.
+function module_to_path(mod)
+   assert(type(mod) == "string")
+   return (mod:gsub("[^.]*$", ""):gsub("%.", dir.separator))
+end
+
+--- Set up path-related variables for a given rock.
+-- Create a "variables" table in the rockspec table, containing
+-- adjusted variables according to the configuration file.
+-- @param rockspec table: The rockspec table.
+function configure_paths(rockspec)
+   assert(type(rockspec) == "table")
+   local vars = {}
+   for k,v in pairs(cfg.variables) do
+      vars[k] = v
+   end
+   local name, version = rockspec.name, rockspec.version
+   vars.PREFIX = install_dir(name, version)
+   vars.LUADIR = lua_dir(name, version)
+   vars.LIBDIR = lib_dir(name, version)
+   vars.CONFDIR = conf_dir(name, version)
+   vars.BINDIR = bin_dir(name, version)
+   vars.DOCDIR = doc_dir(name, version)
+   rockspec.variables = vars
+end
+
+function versioned_name(file, prefix, name, version)
+   assert(type(file) == "string")
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+
+   local rest = file:sub(#prefix+1):gsub("^/*", "")
+   local name_version = (name.."_"..version):gsub("%-", "_"):gsub("%.", "_")
+   return dir.path(prefix, name_version.."-"..rest)
+end
+
+function use_tree(tree)
+   cfg.root_dir = tree
+   cfg.rocks_dir = rocks_dir(tree)
+   cfg.deploy_bin_dir = deploy_bin_dir(tree)
+   cfg.deploy_lua_dir = deploy_lua_dir(tree)
+   cfg.deploy_lib_dir = deploy_lib_dir(tree)
+end
+
+--- Driver function for "path" command.
+-- @return boolean This function always succeeds.
+function run(...)
+   util.printout(cfg.export_lua_path:format(package.path))
+   util.printout(cfg.export_lua_cpath:format(package.cpath))
+   return true
+end
+