rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/luarocks/install.lua

@@ -0,0 +1,151 @@
+
+--- Module implementing the LuaRocks "install" command.
+-- Installs binary rocks.
+module("luarocks.install", package.seeall)
+
+local path = require("luarocks.path")
+local rep = require("luarocks.rep")
+local fetch = require("luarocks.fetch")
+local util = require("luarocks.util")
+local fs = require("luarocks.fs")
+local deps = require("luarocks.deps")
+local manif = require("luarocks.manif")
+local cfg = require("luarocks.cfg")
+
+help_summary = "Install a rock."
+
+help_arguments = "{<rock>|<name> [<version>]}"
+
+help = [[
+Argument may be the name of a rock to be fetched from a repository
+or a filename of a locally available rock.
+]]
+
+--- Install a binary rock.
+-- @param rock_file string: local or remote filename of a rock.
+-- @param no_deps boolean: true if dependency check needs to be skipped
+-- @return boolean or (nil, string, [string]): True if succeeded or 
+-- nil and an error message and an optional error code.
+function install_binary_rock(rock_file, no_deps)
+   assert(type(rock_file) == "string")
+
+   local name, version, arch = path.parse_name(rock_file)
+   if not name then
+      return nil, "Filename "..rock_file.." does not match format 'name-version-revision.arch.rock'."
+   end
+   
+   if arch ~= "all" and arch ~= cfg.arch then
+      return nil, "Incompatible architecture "..arch, "arch"
+   end
+   if rep.is_installed(name, version) then
+      rep.delete_version(name, version)
+   end
+   
+   local rollback = util.schedule_function(function()
+      fs.delete(path.install_dir(name, version))
+      fs.remove_dir_if_empty(path.versions_dir(name))
+   end)
+   
+   local ok, err, errcode = fetch.fetch_and_unpack_rock(rock_file, path.install_dir(name, version))
+   if not ok then return nil, err, errcode end
+   
+   local rockspec, err, errcode = fetch.load_rockspec(path.rockspec_file(name, version))
+   if err then
+      return nil, "Failed loading rockspec for installed package: "..err, errcode
+   end
+
+   if no_deps then
+      util.printerr("Warning: skipping dependency checks.")
+   else
+      ok, err, errcode = deps.check_external_deps(rockspec, "install")
+      if err then return nil, err, errcode end
+   end
+
+   -- For compatibility with .rock files built with LuaRocks 1
+   if not fs.exists(path.rock_manifest_file(name, version)) then
+      ok, err = manif.make_rock_manifest(name, version)
+      if err then return nil, err end
+   end
+
+   if not no_deps then
+      ok, err, errcode = deps.fulfill_dependencies(rockspec)
+      if err then return nil, err, errcode end
+   end
+
+   local wrap_bin_scripts = true
+   if rockspec.deploy and rockspec.deploy.wrap_bin_scripts == false then
+      wrap_bin_scripts = false
+   end
+
+   ok, err = rep.deploy_files(name, version, rep.should_wrap_bin_scripts(rockspec))
+   if err then return nil, err end
+
+   util.remove_scheduled_function(rollback)
+   rollback = util.schedule_function(function()
+      rep.delete_version(name, version)
+   end)
+
+   ok, err = rep.run_hook(rockspec, "post_install")
+   if err then return nil, err end
+   
+   ok, err = manif.update_manifest(name, version)
+   if err then return nil, err end
+   
+   local license = ""
+   if rockspec.description.license then
+      license = ("(license: "..rockspec.description.license..")")
+   end
+
+   local root_dir = path.root_dir(cfg.rocks_dir)
+   util.printout()
+   util.printout(name.." "..version.." is now installed in "..root_dir.." "..license)
+   
+   util.remove_scheduled_function(rollback)
+   return true
+end
+
+--- Driver function for the "install" command.
+-- @param name string: name of a binary rock. If an URL or pathname
+-- to a binary rock is given, fetches and installs it. If a rockspec or a
+-- source rock is given, forwards the request to the "build" command.
+-- If a package name is given, forwards the request to "search" and,
+-- if returned a result, installs the matching rock.
+-- @param version string: When passing a package name, a version number
+-- may also be given.
+-- @return boolean or (nil, string): True if installation 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
+
+   if name:match("%.rockspec$") or name:match("%.src%.rock$") then
+      util.printout("Using "..name.."... switching to 'build' mode")
+      local build = require("luarocks.build")
+      return build.run(name, flags["local"] and "--local")
+   elseif name:match("%.rock$") then
+      return install_binary_rock(name, flags["nodeps"])
+   else
+      local search = require("luarocks.search")
+      local results, err = search.find_suitable_rock(search.make_query(name:lower(), version))
+      if err then
+         return nil, err
+      elseif type(results) == "string" then
+         local url = results
+         util.printout("Installing "..url.."...")
+         return run(url)
+      else
+         util.printout()
+         util.printerr("Could not determine which rock to install.")
+         util.printout()
+         util.printout("Search results:")
+         util.printout("---------------")
+         search.print_results(results)
+         return nil, (next(results) and "Please narrow your query." or "No results found.")
+      end
+   end
+end

data/vendor/lua/lib/lua/luarocks/list.lua

@@ -0,0 +1,35 @@
+
+--- Module implementing the LuaRocks "list" command.
+-- Lists currently installed rocks.
+module("luarocks.list", package.seeall)
+
+local search = require("luarocks.search")
+local cfg = require("luarocks.cfg")
+local util = require("luarocks.util")
+local path = require("luarocks.path")
+
+help_summary = "Lists currently installed rocks."
+
+help = [[
+<argument> is a substring of a rock name to filter by.
+]]
+
+--- Driver function for "list" command.
+-- @param filter string or nil: A substring of a rock name to filter by.
+-- @param version string or nil: a version may also be passed.
+-- @return boolean: True if succeeded, nil on errors.
+function run(...)
+   local flags, filter, version = util.parse_flags(...)
+   local results = {}
+   local query = search.make_query(filter and filter:lower() or "", version)
+   query.exact_name = false
+   for _, tree in ipairs(cfg.rocks_trees) do
+      search.manifest_search(results, path.rocks_dir(tree), query)
+   end
+   util.printout()
+   util.printout("Installed rocks:")
+   util.printout("----------------")
+   util.printout()
+   search.print_results(results, false)
+   return true
+end

data/vendor/lua/lib/lua/luarocks/loader.lua

@@ -0,0 +1,228 @@
+
+--- A module which installs a Lua package loader that is LuaRocks-aware.
+-- This loader uses dependency information from the LuaRocks tree to load
+-- correct versions of modules. It does this by constructing a "context"
+-- table in the environment, which records which versions of packages were
+-- used to load previous modules, so that the loader chooses versions
+-- that are declared to be compatible with the ones loaded earlier.
+local global_env = _G
+local package, require, ipairs, pairs, table, type, next, unpack =
+      package, require, ipairs, pairs, table, type, next, unpack
+
+module("luarocks.loader")
+
+local path = require("luarocks.path")
+local manif_core = require("luarocks.manif_core")
+local deps = require("luarocks.deps")
+local cfg = require("luarocks.cfg")
+
+context = {}
+
+-- Contains a table when rocks trees are loaded,
+-- or 'false' to indicate rocks trees failed to load.
+-- 'nil' indicates rocks trees were not attempted to be loaded yet.
+rocks_trees = nil
+
+local function load_rocks_trees() 
+   local any_ok = false
+   local trees = {}
+   for _, tree in pairs(cfg.rocks_trees) do
+      local manifest, err = manif_core.load_local_manifest(path.rocks_dir(tree))
+      if manifest then
+         any_ok = true
+         table.insert(trees, {tree=tree, manifest=manifest})
+      end
+   end
+   if not any_ok then
+      rocks_trees = false
+      return false
+   end
+   rocks_trees = trees
+   return true
+end
+
+--- Process the dependencies of a package to determine its dependency
+-- chain for loading modules.
+-- @param name string: The name of an installed rock.
+-- @param version string: The version of the rock, in string format
+function add_context(name, version)
+   -- assert(type(name) == "string")
+   -- assert(type(version) == "string")
+
+   if context[name] then
+      return
+   end
+   context[name] = version
+
+   if not rocks_trees and not load_rocks_trees() then
+      return nil
+   end
+
+   local providers = {}
+   for _, tree in pairs(rocks_trees) do
+      local manifest = tree.manifest
+
+      local pkgdeps
+      if manifest.dependencies and manifest.dependencies[name] then
+         pkgdeps = manifest.dependencies[name][version]
+      end
+      if not pkgdeps then
+         return nil
+      end
+      for _, dep in ipairs(pkgdeps) do
+         local pkg, constraints = dep.name, dep.constraints
+   
+         for _, tree in pairs(rocks_trees) do
+            local entries = tree.manifest.repository[pkg]
+            if entries then
+               for version, pkgs in pairs(entries) do
+                  if (not constraints) or deps.match_constraints(deps.parse_version(version), constraints) then
+                     add_context(pkg, version)
+                  end
+               end
+            end
+         end
+      end
+   end
+end
+
+--- Internal sorting function.
+-- @param a table: A provider table.
+-- @param b table: Another provider table.
+-- @return boolean: True if the version of a is greater than that of b.
+local function sort_versions(a,b)
+   return a.version > b.version
+end
+
+--- Request module to be loaded through other loaders,
+-- once the proper name of the module has been determined.
+-- For example, in case the module "socket.core" has been requested
+-- to the LuaRocks loader and it determined based on context that
+-- the version 2.0.2 needs to be loaded and it is not the current
+-- version, the module requested for the other loaders will be
+-- "socket.core_2_0_2".
+-- @param module The module name requested by the user, such as "socket.core"
+-- @param name The rock name, such as "luasocket"
+-- @param version The rock version, such as "2.0.2-1"
+-- @param module_name The actual module name, such as "socket.core" or "socket.core_2_0_2".
+-- @return table or (nil, string): The module table as returned by some other loader,
+-- or nil followed by an error message if no other loader managed to load the module.
+local function call_other_loaders(module, name, version, module_name)
+   for i, loader in pairs(package.loaders) do
+      if loader ~= luarocks_loader then
+         local results = { loader(module_name) }
+         if type(results[1]) == "function" then
+            return unpack(results)
+         end
+      end
+   end
+   return nil, "Failed loading module "..module.." in LuaRocks rock "..name.." "..version
+end
+
+--- Search for a module in the rocks trees
+-- @param module string: module name (eg. "socket.core")
+-- @param filter_module_name function(string, string, string, string, number):
+-- a function that takes the module name (eg "socket.core"), the rock name
+-- (eg "luasocket"), the version (eg "2.0.2-1"), the path of the rocks tree
+-- (eg "/usr/local"), and the numeric index of the matching entry, so the
+-- filter function can know if the matching module was the first entry or not.
+-- @return string, string, string: name of the rock containing the module
+-- (eg. "luasocket"), version of the rock (eg. "2.0.2-1"),
+-- name of the module (eg. "socket.core", or "socket.core_2_0_2" if file is
+-- stored versioned).
+local function select_module(module, filter_module_name)
+   --assert(type(module) == "string")
+   --assert(type(filter_module_name) == "function")
+
+   if not rocks_trees and not load_rocks_trees() then
+      return nil
+   end
+
+   local providers = {}
+   for _, tree in pairs(rocks_trees) do
+      local entries = tree.manifest.modules[module]
+      if entries then
+         for i, entry in ipairs(entries) do
+            local name, version = entry:match("^([^/]*)/(.*)$")
+            local module_name = tree.manifest.repository[name][version][1].modules[module]
+            if type(module_name) ~= "string" then
+               error("Invalid format in manifest file (invalid data for "..tostring(name).." "..tostring(version)..")")
+            end
+            module_name = filter_module_name(module_name, name, version, tree.tree, i)
+            if context[name] == version then
+               return name, version, module_name
+            end
+            version = deps.parse_version(version)
+            table.insert(providers, {name = name, version = version, module_name = module_name})
+         end
+      end
+   end
+
+   if next(providers) then
+      table.sort(providers, sort_versions)
+      local first = providers[1]
+      return first.name, first.version.string, first.module_name
+   end
+end
+
+--- Search for a module
+-- @param module string: module name (eg. "socket.core")
+-- @return string, string, string: name of the rock containing the module
+-- (eg. "luasocket"), version of the rock (eg. "2.0.2-1"),
+-- name of the module (eg. "socket.core", or "socket.core_2_0_2" if file is
+-- stored versioned).
+local function pick_module(module)
+   return
+      select_module(module, function(module_name, name, version, tree, i)
+         if i > 1 then
+            module_name = path.versioned_name(module_name, "", name, version)
+         end
+         module_name = path.path_to_module(module_name)
+         return module_name
+      end)
+end
+
+--- Return the pathname of the file that would be loaded for a module.
+-- @param module string: module name (eg. "socket.core")
+-- @return string, string, string: name of the rock containing the module
+-- (eg. "luasocket"), version of the rock (eg. "2.0.2-1"),
+-- filename of the module (eg. "/usr/local/lib/lua/5.1/socket/core.so")
+function which(module)
+   local name, version, module_name = 
+      select_module(module, function(module_name, name, version, tree, i)
+         local deploy_dir
+         if module_name:match("%.lua$") then
+            deploy_dir = path.deploy_lua_dir(tree)
+            module_name = deploy_dir.."/"..module_name
+         else
+            deploy_dir = path.deploy_lib_dir(tree)
+            module_name = deploy_dir.."/"..module_name
+         end
+         if i > 1 then
+            module_name = path.versioned_name(module_name, deploy_dir, name, version)
+         end
+         return module_name
+      end)
+   return module_name
+end
+
+--- Package loader for LuaRocks support.
+-- A module is searched in installed rocks that match the
+-- current LuaRocks context. If module is not part of the
+-- context, or if a context has not yet been set, the module
+-- in the package with the highest version is used.
+-- @param module string: The module name, like in plain require().
+-- @return table: The module table (typically), like in plain
+-- require(). See <a href="http://www.lua.org/manual/5.1/manual.html#pdf-require">require()</a>
+-- in the Lua reference manual for details.
+function luarocks_loader(module)
+   local name, version, module_name = pick_module(module)
+   if not name then
+      return nil, "No LuaRocks module found for "..module
+   else
+      add_context(name, version)
+      return call_other_loaders(module, name, version, module_name)
+   end
+end
+
+table.insert(global_env.package.loaders, 1, luarocks_loader)

data/vendor/lua/lib/lua/luarocks/make.lua

@@ -0,0 +1,71 @@
+
+--- Module implementing the LuaRocks "make" command.
+-- Builds sources in the current directory, but unlike "build",
+-- it does not fetch sources, etc., assuming everything is 
+-- available in the current directory.
+module("luarocks.make", package.seeall)
+
+local build = require("luarocks.build")
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+local fetch = require("luarocks.fetch")
+local pack = require("luarocks.pack")
+
+help_summary = "Compile package in current directory using a rockspec."
+help_arguments = "[--pack-binary-rock] [<rockspec>]"
+help = [[
+Builds sources in the current directory, but unlike "build",
+it does not fetch sources, etc., assuming everything is 
+available in the current directory. If no argument is given,
+look for a rockspec in the current directory. If more than one
+is found, you must specify which to use, through the command-line.
+
+This command is useful as a tool for debugging rockspecs. 
+To install rocks, you'll normally want to use the "install" and
+"build" commands. See the help on those for details.
+
+If --pack-binary-rock is passed, the rock is not installed;
+instead, a .rock file with the contents of compilation is produced
+in the current directory.
+]]
+
+--- Driver function for "make" command.
+-- @param name string: A local rockspec.
+-- @return boolean or (nil, string): True if build was successful; nil and an
+-- error message otherwise.
+function run(...)
+   local flags, rockspec = util.parse_flags(...)
+   assert(type(rockspec) == "string" or not rockspec)
+   
+   if not rockspec then
+      local files = fs.list_dir(fs.current_dir())
+      for _, file in pairs(files) do
+         if file:match("rockspec$") then
+            if rockspec then
+               return nil, "Please specify which rockspec file to use."
+            else
+               rockspec = file
+            end
+         end
+      end
+      if not rockspec then
+         return nil, "Argument missing: please specify a rockspec to use on current directory."
+      end
+   end
+   if not rockspec:match("rockspec$") then
+      return nil, "Invalid argument: 'make' takes a rockspec as a parameter. See help."
+   end
+
+   if flags["pack-binary-rock"] then
+      local rspec, err, errcode = fetch.load_rockspec(rockspec)
+      if not rspec then
+         return nil, err
+      end
+      return pack.pack_binary_rock(rspec.name, rspec.version, build.build_rockspec, rockspec, false, true, flags["nodeps"])
+   else
+      local ok, err = fs.check_command_permissions(flags)
+      if not ok then return nil, err end
+      return build.build_rockspec(rockspec, false, true)
+   end
+end