From d53493179d3e16b3f2cc22470483c2926c457751 Mon Sep 17 00:00:00 2001 From: V1K1NGbg Date: Mon, 10 Jun 2024 02:33:37 +0200 Subject: core.path - converted --- src/luarocks/core/path-original.lua | 157 ++++++++++++++++++++++++++++++++++ src/luarocks/core/path.lua | 77 +++++++++-------- src/luarocks/core/path.tl | 166 ++++++++++++++++++++++++++++++++++++ 3 files changed, 366 insertions(+), 34 deletions(-) create mode 100644 src/luarocks/core/path-original.lua create mode 100644 src/luarocks/core/path.tl (limited to 'src') diff --git a/src/luarocks/core/path-original.lua b/src/luarocks/core/path-original.lua new file mode 100644 index 00000000..2f037b41 --- /dev/null +++ b/src/luarocks/core/path-original.lua @@ -0,0 +1,157 @@ + +--- Core LuaRocks-specific path handling functions. +local path = {} + +local cfg = require("luarocks.core.cfg") +local dir = require("luarocks.core.dir") +local require = nil + +local dir_sep = package.config:sub(1, 1) +-------------------------------------------------------------------------------- + +function path.rocks_dir(tree) + if tree == nil then + tree = cfg.root_dir + end + if type(tree) == "string" then + return dir.path(tree, cfg.rocks_subdir) + end + assert(type(tree) == "table") + return tree.rocks_dir or dir.path(tree.root, cfg.rocks_subdir) +end + +--- Produce a versioned version of a filename. +-- @param file string: filename (must start with prefix) +-- @param prefix string: Path prefix for file +-- @param name string: Rock name +-- @param version string: Rock version +-- @return string: a pathname with the same directory parts and a versioned basename. +function path.versioned_name(file, prefix, name, version) + assert(type(file) == "string") + assert(type(name) == "string" and not name:match(dir_sep)) + assert(type(version) == "string") + + local rest = file:sub(#prefix+1):gsub("^" .. dir_sep .. "*", "") + local name_version = (name.."_"..version):gsub("%-", "_"):gsub("%.", "_") + return dir.path(prefix, name_version.."-"..rest) +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.init"; "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.path_to_module(file) + assert(type(file) == "string") + + local exts = {} + local paths = package.path .. ";" .. package.cpath + for entry in paths:gmatch("[^;]+") do + local ext = entry:match("%.([a-z]+)$") + if ext then + exts[ext] = true + end + end + + local name + for ext, _ in pairs(exts) do + name = file:match("(.*)%." .. ext .. "$") + if name then + name = name:gsub("[\\/]", ".") + break + end + end + + if not name then name = file end + + -- remove any beginning and trailing slashes-converted-to-dots + name = name:gsub("^%.+", ""):gsub("%.+$", "") + + return name +end + +function path.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 path.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 + +local is_src_extension = { [".lua"] = true, [".tl"] = true, [".tld"] = true, [".moon"] = true } + +--- Return the pathname of the file that would be loaded for a module, indexed. +-- @param file_name string: module file name as in manifest (eg. "socket/core.so") +-- @param name string: name of the package (eg. "luasocket") +-- @param version string: version number (eg. "2.0.2-1") +-- @param tree string: repository path (eg. "/usr/local") +-- @param i number: the index, 1 if version is the current default, > 1 otherwise. +-- This is done this way for use by select_module in luarocks.loader. +-- @return string: filename of the module (eg. "/usr/local/lib/lua/5.1/socket/core.so") +function path.which_i(file_name, name, version, tree, i) + local deploy_dir + local extension = file_name:match("%.[a-z]+$") + if is_src_extension[extension] then + deploy_dir = path.deploy_lua_dir(tree) + file_name = dir.path(deploy_dir, file_name) + else + deploy_dir = path.deploy_lib_dir(tree) + file_name = dir.path(deploy_dir, file_name) + end + if i > 1 then + file_name = path.versioned_name(file_name, deploy_dir, name, version) + end + return file_name +end + +function path.rocks_tree_to_string(tree) + if type(tree) == "string" then + return tree + else + assert(type(tree) == "table") + return tree.root + end +end + +--- Apply a given function to the active rocks trees based on chosen dependency mode. +-- @param deps_mode string: Dependency mode: "one" for the current default tree, +-- "all" for all trees, "order" for all trees with priority >= the current default, +-- "none" for no trees (this function becomes a nop). +-- @param fn function: function to be applied, with the tree dir (string) as the first +-- argument and the remaining varargs of map_trees as the following arguments. +-- @return a table with all results of invocations of fn collected. +function path.map_trees(deps_mode, fn, ...) + local result = {} + local current = cfg.root_dir or cfg.rocks_trees[1] + if deps_mode == "one" then + table.insert(result, (fn(current, ...)) or 0) + else + local use = false + if deps_mode == "all" then + use = true + end + for _, tree in ipairs(cfg.rocks_trees or {}) do + if dir.normalize(path.rocks_tree_to_string(tree)) == dir.normalize(path.rocks_tree_to_string(current)) then + use = true + end + if use then + table.insert(result, (fn(tree, ...)) or 0) + end + end + end + return result +end + +return path diff --git a/src/luarocks/core/path.lua b/src/luarocks/core/path.lua index 2f037b41..abfcb34d 100644 --- a/src/luarocks/core/path.lua +++ b/src/luarocks/core/path.lua @@ -1,13 +1,22 @@ +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 assert = _tl_compat and _tl_compat.assert or assert; local ipairs = _tl_compat and _tl_compat.ipairs or ipairs; 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 ---- Core LuaRocks-specific path handling functions. local path = {} + + + + + + + + + local cfg = require("luarocks.core.cfg") local dir = require("luarocks.core.dir") local require = nil local dir_sep = package.config:sub(1, 1) --------------------------------------------------------------------------------- + function path.rocks_dir(tree) if tree == nil then @@ -20,29 +29,29 @@ function path.rocks_dir(tree) return tree.rocks_dir or dir.path(tree.root, cfg.rocks_subdir) end ---- Produce a versioned version of a filename. --- @param file string: filename (must start with prefix) --- @param prefix string: Path prefix for file --- @param name string: Rock name --- @param version string: Rock version --- @return string: a pathname with the same directory parts and a versioned basename. + + + + + + function path.versioned_name(file, prefix, name, version) assert(type(file) == "string") assert(type(name) == "string" and not name:match(dir_sep)) assert(type(version) == "string") - local rest = file:sub(#prefix+1):gsub("^" .. dir_sep .. "*", "") - local name_version = (name.."_"..version):gsub("%-", "_"):gsub("%.", "_") - return dir.path(prefix, name_version.."-"..rest) + local rest = file:sub(#prefix + 1):gsub("^" .. dir_sep .. "*", "") + local name_version = (name .. "_" .. version):gsub("%-", "_"):gsub("%.", "_") + return dir.path(prefix, name_version .. "-" .. rest) 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.init"; "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.path_to_module(file) assert(type(file) == "string") @@ -66,7 +75,7 @@ function path.path_to_module(file) if not name then name = file end - -- remove any beginning and trailing slashes-converted-to-dots + name = name:gsub("^%.+", ""):gsub("%.+$", "") return name @@ -92,14 +101,14 @@ end local is_src_extension = { [".lua"] = true, [".tl"] = true, [".tld"] = true, [".moon"] = true } ---- Return the pathname of the file that would be loaded for a module, indexed. --- @param file_name string: module file name as in manifest (eg. "socket/core.so") --- @param name string: name of the package (eg. "luasocket") --- @param version string: version number (eg. "2.0.2-1") --- @param tree string: repository path (eg. "/usr/local") --- @param i number: the index, 1 if version is the current default, > 1 otherwise. --- This is done this way for use by select_module in luarocks.loader. --- @return string: filename of the module (eg. "/usr/local/lib/lua/5.1/socket/core.so") + + + + + + + + function path.which_i(file_name, name, version, tree, i) local deploy_dir local extension = file_name:match("%.[a-z]+$") @@ -125,13 +134,13 @@ function path.rocks_tree_to_string(tree) end end ---- Apply a given function to the active rocks trees based on chosen dependency mode. --- @param deps_mode string: Dependency mode: "one" for the current default tree, --- "all" for all trees, "order" for all trees with priority >= the current default, --- "none" for no trees (this function becomes a nop). --- @param fn function: function to be applied, with the tree dir (string) as the first --- argument and the remaining varargs of map_trees as the following arguments. --- @return a table with all results of invocations of fn collected. + + + + + + + function path.map_trees(deps_mode, fn, ...) local result = {} local current = cfg.root_dir or cfg.rocks_trees[1] diff --git a/src/luarocks/core/path.tl b/src/luarocks/core/path.tl new file mode 100644 index 00000000..7c664fda --- /dev/null +++ b/src/luarocks/core/path.tl @@ -0,0 +1,166 @@ + +--- Core LuaRocks-specific path handling functions. +local record path + rocks_dir: function(tree: string | {any: any}): string --? string or table? + versioned_name: function(file: string, prefix: string, name: string, version: string): string + path_to_module: function(file: string): string + deploy_lua_dir: function(tree: string | {any: any}): string --? string or table? + deploy_lib_dir: function(tree: string | {any: any}): string --? string or table? + which_i: function(file_name: string, name: string, version: string, tree: string, i: number): string + rocks_tree_to_string: function(tree: string | {any: any}): string --? string or table? + map_trees: function(deps_mode: string, fn: function, ...: string): {any} +end + +local cfg = require("luarocks.core.cfg") --! +local dir = require("luarocks.core.dir") +local require = nil --! + +local dir_sep = package.config:sub(1, 1) +-------------------------------------------------------------------------------- + +function path.rocks_dir(tree: string | {any: any}): string --? string or table? + if tree == nil then + tree = cfg.root_dir + end + if type(tree) == "string" then + return dir.path(tree, cfg.rocks_subdir) + end + assert(type(tree) == "table") --? needed + return tree.rocks_dir or dir.path(tree.root, cfg.rocks_subdir) --! +end + +--- Produce a versioned version of a filename. +-- @param file string: filename (must start with prefix) +-- @param prefix string: Path prefix for file +-- @param name string: Rock name +-- @param version string: Rock version +-- @return string: a pathname with the same directory parts and a versioned basename. +function path.versioned_name(file: string, prefix: string, name: string, version: string): string + assert(type(file) == "string") --? needed + assert(type(name) == "string" and not name:match(dir_sep)) + assert(type(version) == "string") + + local rest = file:sub(#prefix+1):gsub("^" .. dir_sep .. "*", "") + local name_version = (name.."_"..version):gsub("%-", "_"):gsub("%.", "_") + return dir.path(prefix, name_version.."-"..rest) +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.init"; "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.path_to_module(file: string): string + assert(type(file) == "string") + + local exts = {} + local paths = package.path .. ";" .. package.cpath + for entry in paths:gmatch("[^;]+") do + local ext = entry:match("%.([a-z]+)$") + if ext then + exts[ext] = true + end + end + + local name: string + for ext, _ in pairs(exts) do + name = file:match("(.*)%." .. ext .. "$") + if name then + name = name:gsub("[\\/]", ".") + break + end + end + + if not name then name = file end + + -- remove any beginning and trailing slashes-converted-to-dots + name = name:gsub("^%.+", ""):gsub("%.+$", "") + + return name +end + +function path.deploy_lua_dir(tree: string | {any: any}): string --? string or table? + 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 path.deploy_lib_dir(tree: string | {any: any}): string --? string or table? + 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 + +local is_src_extension: {string: boolean} = { [".lua"] = true, [".tl"] = true, [".tld"] = true, [".moon"] = true } + +--- Return the pathname of the file that would be loaded for a module, indexed. +-- @param file_name string: module file name as in manifest (eg. "socket/core.so") +-- @param name string: name of the package (eg. "luasocket") +-- @param version string: version number (eg. "2.0.2-1") +-- @param tree string: repository path (eg. "/usr/local") +-- @param i number: the index, 1 if version is the current default, > 1 otherwise. +-- This is done this way for use by select_module in luarocks.loader. +-- @return string: filename of the module (eg. "/usr/local/lib/lua/5.1/socket/core.so") +function path.which_i(file_name: string, name: string, version: string, tree: string, i: number): string + local deploy_dir: string + local extension = file_name:match("%.[a-z]+$") + if is_src_extension[extension] then + deploy_dir = path.deploy_lua_dir(tree) + file_name = dir.path(deploy_dir, file_name) + else + deploy_dir = path.deploy_lib_dir(tree) + file_name = dir.path(deploy_dir, file_name) + end + if i > 1 then + file_name = path.versioned_name(file_name, deploy_dir, name, version) + end + return file_name +end + +function path.rocks_tree_to_string(tree: string | {any: any}): string --? string or table? + if type(tree) == "string" then + return tree + else + assert(type(tree) == "table") + return tree.root + end +end + +--- Apply a given function to the active rocks trees based on chosen dependency mode. +-- @param deps_mode string: Dependency mode: "one" for the current default tree, +-- "all" for all trees, "order" for all trees with priority >= the current default, +-- "none" for no trees (this function becomes a nop). +-- @param fn function: function to be applied, with the tree dir (string) as the first +-- argument and the remaining varargs of map_trees as the following arguments. +-- @return a table with all results of invocations of fn collected. +function path.map_trees(deps_mode: string, fn: function, ...: string): {any} --? ... string + local result = {} + local current = cfg.root_dir or cfg.rocks_trees[1] + if deps_mode == "one" then + table.insert(result, (fn(current, ...)) or 0) + else + local use = false + if deps_mode == "all" then + use = true + end + for _, tree in ipairs(cfg.rocks_trees or {}) do --! + if dir.normalize(path.rocks_tree_to_string(tree)) == dir.normalize(path.rocks_tree_to_string(current)) then --! + use = true + end + if use then + table.insert(result, (fn(tree, ...)) or 0) + end + end + end + return result +end + +return path -- cgit v1.2.3-55-g6feb