--[[--------------------
# Lubyk base module 
This module contains core functions (code loading, templates, helpers).
*MIT license* © Gaspard Bucher 2014.
## Installation
With [luarocks](http://luarocks.org):
$ luarocks install lub
--]]--------------------
local lfs = require 'lfs'
local private = {}
local format, gsub, sub, match, len, pairs, ipairs =
string.format, string.gsub, string.sub, string.match, string.len, pairs, ipairs
local yield, insert, sort, remove, type =
coroutine.yield, table.insert, table.sort, table.remove, type
local TAIL_CALL = rawget(_G, 'setfenv') and '%(tail call%)' or '%(%.%.%.tail calls%.%.%.%)'
local CALL_TO_NEW = {__call = function(lib, ...) return lib.new(...) end}
local lib = {}
--[[------------------------------------------------------
The module also contains utility functions related to path
management, script introspection and some string/array methods.
--]]------------------------------------------------------
-- ## Dependencies
--
-- Current version respecting [semantic versioning](http://semver.org).
lib.VERSION = '1.1.0'
lib.DEPENDS = { -- doc
-- Compatible with Lua 5.1 to 5.3 and LuaJIT
"lua >= 5.1, < 5.4",
-- Uses [Lua Filesystem](http://keplerproject.github.io/luafilesystem/)
"luafilesystem >= 1.4.0",
}
-- Basic description for luarocks.
lib.DESCRIPTION = {
summary = "Lubyk base module.",
detailed = [[
lub: helper code, class declaration.
lub.Autoload: autoloading classes in modules.
lub.Dir: a simple directory traversal class.
lub.Template: a simple templating class that uses {{moustache}} like syntax.
lub.Param: script parameter save/restore.
]],
homepage = "http://doc.lubyk.org/lub.html",
author = "Gaspard Bucher",
license = "MIT",
}
-- Build settings for lut.Builder
lib.BUILD = {
github = "lubyk",
pure_lua = true,
}
local SYSTINFO
-- # Environment information
--
-- Get name of currently running platform. Values are 'linux',
-- 'macosx', 'unix' and 'win32'. Returns "platform", "platform detail", "system"
--
-- Platform detail is MinGW or Cygwin for example.
--
function lib.plat()
if not SYSTINFO then
local cfg = require 'luarocks.cfg'
local ok, system = pcall(function()
return io.popen("uname -s"):read("*l")
end)
if not ok then
error('Cannot get platform information without "io.popen"')
end
SYSTINFO = {SYSTEM = system}
if system == 'Darwin' then
SYSTINFO.PLAT = 'macosx'
elseif system:match('^CYGWIN') then
SYSTINFO.PLAT = 'win32'
SYSTINFO.PLAT_DETAIL = 'Cygwin'
elseif system and system:match("^Windows") then
SYSTINFO.PLAT = 'win32'
SYSTINFO.PLAT_DETAIL = 'Windows'
elseif system and system:match("^MINGW") then
SYSTINFO.PLAT = 'win32'
SYSTINFO.PLAT_DETAIL = 'MinGW'
else
SYSTINFO.PLAT = 'unix'
end
end
return SYSTINFO.PLAT, SYSTINFO.PLAT_DETAIL, SYSTINFO.SYSTEM
end
-- # Class management
--
-- Declare a new class with the following conventions:
--
-- * The `.type` field contains the full class name.
-- * The returned table is the metatable for all instances of this class and
-- contains the functions.
-- * Calling the table with `foo.Bar()` is an alias for a call to
-- `foo.Bar.new`.
--
-- Usage:
--
-- local lub = require 'lub'
-- local lut = require 'lut'
-- local lib = lub.class 'lut.Doc'
--
-- -- ...
-- return lib
--
-- WARN When using an initial lua table, make sure to use parenthesis around the
-- function call:
--
-- local lib = lub.class('lut.Doc', {
-- is_cool = true,
-- })
--
function lib.class(class_name, tbl)
local lib = tbl or {}
lib.type = class_name
lib.__index = lib
return setmetatable(lib, CALL_TO_NEW)
end
-- # Algorithm
-- Search a tree using lua function for node testing or collecting. This method
-- is an alias for #BFS.
--
-- Optional argument `max_depth` is to avoid hanging in case the data contains
-- loops. The default value for `max_depth` is 3000.
--
-- If the function `func` used for testing returns any value different from
-- false or nil, the search is terminated and this value is returned.
--
-- Example to find an element in an xml tree:
--
-- local poor_guy = lub.search(data, function(node)
-- if node.xml == 'Person' and node.status == 'poor' then
-- return node
-- end
-- end)
--
-- Example to collect elements:
--
-- local list = {}
-- lub.search(data, function(node)
-- if node.xml == 'Person' then
-- table.insert(list, node)
-- end
-- end
--
-- ## Speed
--
-- The traversal speed depends on whether we are using Lua or LuaJIT. The tests
-- below were done on a relatively large medical XML file without very deep
-- nesting.
--
-- #txt ascii
-- ===== Lua
-- IDDFS 5.10
-- BFS 2.58
-- ===== LuaJIT
-- IDDFS 0.30
-- BFS 0.36
-- function lib.search(data, func, max_depth)
-- Iterative deepening depth-first search
local function itdeepSearch(data, func, depth, max_depth)
local end_reached = true
local result
for _, child in ipairs(data) do
if type(child) == 'table' then
if depth == max_depth then
local r = func(child)
if r then
return r
elseif child[1] then
-- Could search deeper
end_reached = false
end
elseif child[1] then
-- Go deeper
local r, e = itdeepSearch(child, func, depth + 1, max_depth)
if r then
return r
else
end_reached = end_reached and e
end
end
end
end
return nil, end_reached
end
-- [Iterative deepening depth-first search](https://en.wikipedia.org/wiki/Iterative_deepening_depth-first_search) with max depth testing. See #search for usage.
function lib.IDDFS(data, func, max_depth)
local depth = 1
max_depth = max_depth or 3000
key = key or 'xml'
local r = func(data)
if r then return r end
while true do
local result, end_reached = itdeepSearch(data, func, 1, depth)
if result then
return result
elseif end_reached then
return nil
elseif depth < max_depth then
depth = depth + 1
else
error(format('Could not finish search: maximal depth of %i reached.', max_depth))
end
end
end
-- [Breath-first search](https://en.wikipedia.org/wiki/Breadth-first_search) with max depth testing. See #search for usage.
function lib.BFS(data, func, max_depth)
local max_depth = max_depth or 3000
local queue = {}
local depth = {} -- depth queue
local head = 1
local tail = 1
local function push(e, d)
queue[tail] = e
depth[tail] = d
tail = tail + 1
end
local function pop()
if head == tail then return nil end
local e, d = queue[head], depth[head]
head = head + 1
return e, d
end
local elem = data
local d = 1
while elem and d <= max_depth do
local r = func(elem)
if r then return elem end
for _, child in ipairs(elem) do
if type(child) == 'table' then
push(child, d + 1)
end
end
elem, d = pop()
end
if d and d > max_depth then
error(format('Could not finish search: maximal depth of %i reached.', max_depth))
else
return nil
end
end
-- nodoc
lib.search = lib.BFS
-- # Filesystem
-- Find the source of the current file or the file up x levels in the call
-- chain (-1 = up one level).
local function scriptSource(level)
local level = level or 0
return debug.getinfo(2 - level).source
end
-- Find the path of the current script or the script up x levels in the call
-- chain (-1 = up one level). The path is relative to the current directory.
--
-- -- get path of running script
-- local my_path = lub.scriptPath()
-- --> 'test/lk_test.lua'
--
-- If you need an absolute path, use #absolutizePath.
local function scriptPath(level)
local level = level or 0
return match(scriptSource(level - 1), '^@(.*)$')
end
-- Find the directory of the current script or the directory of the script up x
-- levels in the call chain (-1 = up one level). This is the same as #scriptPath
-- but it returns the parent directory.
local function scriptDir(level)
local level = level or 0
local file = scriptPath(level - 1)
assert(file, "Cannot use scriptDir here because of a tail call optimization.\n"..debug.traceback())
if match(file, '/') then
local p = gsub(file, '/[^/]+$', '')
return p
else
return '.'
end
end
-- Return a path by resolving special initial characters. The `level` argument
-- can move further up the call hierarchy before resolving paths (use `1` to
-- move up one call). Special
-- initial characters are:
--
-- + `/` : absolute path, resolves '..' in path.
-- + `|` : path relative to script directory, resolves '..' in path.
-- + `&` : returns current script path.
--
-- For example:
--
-- print(lub.path '|')
-- --> current script directory
--
-- print(lub.path '|..')
-- --> parent of script directory
--
function lib.path(path, level)
level = level or 2
local chr = sub(path, 1, 1)
if chr == '|' or chr == '&' then
local src = debug.getinfo(level).source
if src:match(TAIL_CALL) then
src = debug.getinfo(level + 1).source
end
local s = match(src, '^@(.*)$')
if chr == '&' then
return s
end
local b = lib.dir(s)
if len(path) == 1 then return b end
local r = sub(path, 2, -1)
return lib.absolutizePath(b..'/'..r)
else
return lib.absolutizePath(path)
end
end
-- Test for file/directory existence at `path`. If the element exists, returns
-- the file type such as *'directory'* or *'file'*. Returns nil if there is
-- nothing at the given path.
function lib.fileType(path)
if not path then return nil end
local attrs = lfs.attributes(path)
return attrs and attrs.mode
end
-- Return true if the file or folder pointed by `path` exists.
-- function lib.exist(path)
-- nodoc
lib.exist = lib.fileType
-- Return the content of a file as a lua string (not suitable for very long
-- content where parsing the file chunks by chunks is better). The method
-- accepts either a single `path` argument or a `basepath` and relative `path`.
function lib.content(basepath, path)
if path then
path = format('%s/%s', basepath, path)
else
path = basepath
end
local f = assert(io.open(path, 'rb'))
local s = f:read('*all')
f:close()
return s
end
-- Write `data` to `filepath`, creating path folders if necessary. If
-- `check_diff` is true, only write if the content has changed to avoid
-- changing stat information on the file.
function lib.writeall(filepath, data, check_diff)
-- get base directory and build components if necessary
lib.makePath(lib.dir(filepath))
if check_diff and lib.exist(filepath) then
if data == lib.content(filepath) then
return true
end
end
local f = assert(io.open(filepath, 'wb'))
local s = f:write(data)
f:close()
return s
end
-- Build necessary folders to create a given `path`.
function lib.makePath(path)
local fullpath = lib.absolutizePath(path)
private.makePathPart(fullpath, fullpath)
end
-- Move a file or directory from `path` to `new_path`. This is like "os.rename"
-- but it also builds necessary path components in new_path.
function lib.move(path, new_path)
lib.makePath(lib.dir(new_path))
return os.rename(path, new_path)
end
-- Copy a file from `path` to `new_path`. Builds necessary path components
-- in new_path.
function lib.copy(path, new_path)
lib.makePath(lib.dir(new_path))
return os.execute(format('cp %s %s', lib.shellQuote(path), lib.shellQuote(new_path)))
end
-- Delete the file located at `path`. Does nothing if the element at `path` does
-- not exist (already removed).
function lib.rmFile(path)
local typ = lib.fileType(path)
if not typ then return end
assert(typ == 'file', format("Cannot remove '%s': it is a %s.", path, typ))
os.remove(path)
end
-- Remove the directory at `path`. If `recursive` is true, remove recursively.
-- *This is a dangerous method* if the source path is not ensured to be exempt
-- of mistakes.
function lib.rmTree(path, recursive)
local fullpath = lib.absolutizePath(path)
if not lib.exist(fullpath) then
return true
end
if fullpath ~= '/' and fullpath ~= '' then
-- bug paranoia
if not recursive then
return lfs.rmdir(fullpath)
else
local code = format('rm -r %s', lib.shellQuote(fullpath))
if os.execute(code) == 0 then
return true
else
return false
end
end
end
end
-- Return the parent folder and filename from a `filepath`. Usage:
--
-- local base, file = lub.dir(filepath)
--
-- This can also be used on urls.
function lib.dir(filepath)
local base, file = match(filepath, '(.*)/(.*)$')
if not base then
return '.', filepath
elseif base == '' then
-- '/' == root ?
return '/', file
else
return base, file
end
end
-- nodoc
function lib.pathDir(...)
return lib.deprecation('lub', 'pathDir', 'dir', ...)
end
-- Return an absolute path from a `path` and optional `basepath`. If basepath is
-- not provided, the method uses the current directory. This method
-- resolves `/../` and `/./` in paths and returns a clean path. Can also be
-- used with urls.
--
-- For example:
--
-- local abs_path = lub.absolutizePath('foo/bar/../baz', '/home')
-- --> '/home/foo/baz'
function lib.absolutizePath(path, basepath)
if not match(path, '^/') then
path = format('%s/%s', basepath or lfs.currentdir(), path)
end
-- resolve '/./' and '/../'
local parts = lib.split(path, '/')
local path = {}
for i, part in ipairs(parts) do
if part == '.' then
-- ignore
elseif part == '..' then
-- move back
-- 1 = '', 2 = 'xxx', 3 = '..' ==> 1 = ''
if i > 2 then
remove(path, #path)
end
else
insert(path, part)
end
end
return lib.join(path, '/')
end
-- Transform an absolute path or url to a relative path with given base. For
-- example:
--
-- local rel = lub.absToRel('/home/foo/bar', '/home/foo/baz')
-- --> '/home/foo/bar'
-- local rel = lub.absToRel('/home/foo/bar', '/home/foo')
-- --> 'bar'
function lib.absToRel(abs_string, base)
local l = string.len(base)
local s = string.sub(abs_string, 1, l)
if s == base then
if base == abs_string then
return abs_string
else
return string.sub(abs_string, l+2, -1)
end
else
return abs_string
end
end
-- # Strings, Arrays
-- Removes white spaces at the beginning and end of the string `str`.
function lib.strip(str)
return match(str, '^[ \t\n\r]*(.-)[ \t\n\r]*$')
end
-- Split a string `str` into elements separated by the pattern `pat`. The
-- function returns a table.
--
-- local t = lub.split('foo/bar/baz', '/')
-- --> {'foo', 'bar', 'baz'}
function lib.split(str, pat)
local t = {} -- NOTE: use {n = 0} in Lua-5.0
if not pat then
local i = 1
while true do
local s = string.sub(str, i, i)
if s == '' then
break
else
insert(t, s)
end
i = i + 1
end
else
local fpat = '(.-)' .. pat
local last_end = 1
local s, e, cap = string.find(str,fpat, 1)
while s do
insert(t,cap)
last_end = e+1
s, e, cap = str:find(fpat, last_end)
end
if last_end <= #str then
cap = str:sub(last_end)
insert(t, cap)
end
end
return t
end
-- Join elements of a table `list` with separator `sep`. Returns a string.
--
-- local x = lub.join({'foo', 'bar', 'baz'}, '.')
-- --> 'foo.bar.baz'
function lib.join(list, sep)
local res = nil
for _, part in ipairs(list) do
if not res then
res = part
else
res = res .. sep .. part
end
end
return res or ''
end
-- Get the ordered list of *string* keys from a table. If `no_order` is true, keys are
-- not sorted.
function lib.keys(dict, no_order)
local res, n = {}, 0
for k, v in pairs(dict) do
if type(k) == 'string' then
n = n + 1
res[n] = k
end
end
if not no_order then
sort(res)
end
return res
end
-- Insert `elem` into a `list`, keeping entries in "list" sorted. If elem is not
-- a string, the `elem[key]` is used to get a string for sorting.
function lib.insertSorted(list, elem, key)
local pos = -1
for i, n in ipairs(list) do
local a, b = n, elem
if key then
a = a[key]
b = b[key]
end
if a > b then
pos = i
break
end
end
if pos == -1 then
insert(list, elem)
else
insert(list, pos, elem)
end
end
-- Merge values in `table` inside `source`. All keys are considered (array and
-- hash).
function lib.merge(source, table)
for k, v in pairs(table) do
source[k] = v
end
end
local function deepMerge(base, key, value)
local base_v = base[key]
if type(value) == 'table' then
if not base_v then
base[key] = value
return true
else
-- merge
local changed = false
for k, v in pairs(value) do
changed = deepMerge(base_v, k, v) or changed
end
return changed
end
elseif base_v == value then
-- nothing changed
return false
else
base[key] = value
return true
end
end
-- nodoc
lib.deepMerge = deepMerge
-- Deep merge `value` into `base` at `key`. Returns true if *base* has been
-- changed. For example:
--
-- local base = {a = { b = 4, c = 5 }}
-- lub.deepMerge(base, 'a', { c = 5 })
-- --> false (nothing changed)
--
-- lub.deepMerge(base, 'a', { c = 6 })
-- --> true, base = {a = { b = 4, c = 6 }}
-- function lib.deepMerge(base, key, value)
-- # Debugging
local orig_req = require
-- Print calls to `require`. This can be used to list all code dependencies.
-- Usage:
--
-- lub.traceRequire(true)
-- -- From now on, all require statements are printed.
--
-- If you simply want to make sure no `require` is called to autoload code
-- after some point, you should use [Autoload.strict](Autoload.html#strict).
function lib.traceRequire(enable)
if enable then
require = function(path)
print("require '"..path.."'")
return orig_req(path)
end
else
require = orig_req
end
end
-- Print a log message with the current file name and line. This is better then
-- using "print" because it gives us some information on the context of the
-- print statement.
--
-- lub.log('foo')
-- --> lub/util.lua:426: foo
function lib.log(...)
local trace = lib.split(debug.traceback(), '\n\t')
local part = trace[3]
if part:match(TAIL_CALL) then
part = trace[4]
end
local file, line = match(part, '^([^:]+):([^:]+):')
if file and line then
print(format('%s:%i:', file, line), ...)
else
print(part, ...)
end
end
-- # Miscellanous
-- Declare a method as being deprecated. This should be used when method names
-- are changed to avoid breaking code without warnings. The syntax is:
--
-- function lib.badName(...)
-- return lib.deprecation('lub', 'badName', 'betterName', ...)
-- end
--
-- When someone uses the "badName" method, a deprecation warning is printed:
--
-- [DEPRECATION] {traceback}
-- 'lub.badName' is deprecated. Please use 'lub.betterName' instead.
function lib.deprecation(lib_name, old, new, ...)
local trace = lib.split(debug.traceback(), '\n\t')[4]
local arg = ...
if arg then
print(format("[DEPRECATION] %s\n\t'%s.%s' is deprecated. Please use '%s.%s' instead.", trace, lib_name, old, lib_name, new))
return package.loaded[lib_name][new](...)
else
print(format("[DEPRECATION] %s\n\t'%s.%s' is deprecated and will be removed. Please use '%s' instead.", trace, lib_name, old, new))
end
end
-- Quote string `str` so that it can be inserted in a shell command. Example:
--
-- os.execute(string.format('latex %s', lub.shellQuote(filepath)))
function lib.shellQuote(str)
return '"' .. gsub(str, '[\\%$"]', function(x)
return '\\' .. x
end) .. '"'
end
function private.makePathPart(path, fullpath)
local file_type = lib.fileType(path)
if file_type == 'file' then
error(format("Could not build path '%s' ('%s' is a file).", fullpath, path))
elseif file_type == 'directory' then
return -- done
else
local base = lib.dir(path)
private.makePathPart(base, fullpath)
-- base should exist or an error has been raised
lfs.mkdir(path)
-- done
end
end
-- We only enable autoload once all is loaded so that the 'Autoload' class finds
-- 'lub' library.
package.loaded.lub = lib
-- nodoc
lib.Autoload = require 'lub.Autoload'
lib.Autoload('lub', lib)
-- # Classes
return lib