|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return function(lfs) |
|
|
local os = require "os" |
|
|
|
|
|
local DIR_SEP = package.config:sub(1,1) |
|
|
local IS_WINDOWS = DIR_SEP == '\\' |
|
|
|
|
|
local _M = { |
|
|
DIR_SEP = DIR_SEP; |
|
|
} |
|
|
|
|
|
_M.currentdir = lfs.currentdir |
|
|
|
|
|
_M.attributes = lfs.attributes |
|
|
|
|
|
|
|
|
|
|
|
local attrib = lfs.attributes |
|
|
|
|
|
function _M.ctime(P) return attrib(P,'change') end |
|
|
|
|
|
function _M.atime(P) return attrib(P,'access') end |
|
|
|
|
|
function _M.mtime(P) return attrib(P,'modification') end |
|
|
|
|
|
function _M.size(P) return attrib(P,'size') end |
|
|
|
|
|
function _M.exists(P) return attrib(P,'mode') ~= nil and P end |
|
|
|
|
|
function _M.isdir(P) return attrib(P,'mode') == 'directory' and P end |
|
|
|
|
|
function _M.isfile(P) return attrib(P,'mode') == 'file' and P end |
|
|
|
|
|
function _M.islink(P) return attrib(P,'mode') == 'link' and P end |
|
|
|
|
|
_M.mkdir = lfs.mkdir |
|
|
|
|
|
_M.rmdir = lfs.rmdir |
|
|
|
|
|
_M.chdir = lfs.chdir |
|
|
|
|
|
_M.link = lfs.link |
|
|
|
|
|
_M.setmode = lfs.setmode |
|
|
|
|
|
function _M.copy(src, dst, force) |
|
|
if not IS_WINDOWS then |
|
|
if _M.isdir(src) or _M.isdir(dst) then |
|
|
return nil, 'can not copy directories' |
|
|
end |
|
|
end |
|
|
local f, err = io.open(src, 'rb') |
|
|
if not f then return nil, err end |
|
|
|
|
|
if not force then |
|
|
local t, err = io.open(dst, 'rb' ) |
|
|
if t then |
|
|
f:close() |
|
|
t:close() |
|
|
return nil, "file alredy exists" |
|
|
end |
|
|
end |
|
|
|
|
|
local t, err = io.open(dst, 'w+b') |
|
|
if not t then |
|
|
f:close() |
|
|
return nil, err |
|
|
end |
|
|
|
|
|
local CHUNK_SIZE = 4096 |
|
|
while true do |
|
|
local chunk = f:read(CHUNK_SIZE) |
|
|
if not chunk then break end |
|
|
local ok, err = t:write(chunk) |
|
|
if not ok then |
|
|
t:close() |
|
|
f:close() |
|
|
return nil, err or "can not write" |
|
|
end |
|
|
end |
|
|
|
|
|
t:close() |
|
|
f:close() |
|
|
return true |
|
|
end |
|
|
|
|
|
function _M.move(src, dst, flags) |
|
|
if flags and _M.exists(dst) and _M.exists(src) then |
|
|
local ok, err = _M.remove(dst) |
|
|
|
|
|
|
|
|
if not ok then return nil, err end |
|
|
end |
|
|
if (not IS_WINDOWS) and _M.exists(dst) then |
|
|
|
|
|
|
|
|
return nil, "destination alredy exists" |
|
|
end |
|
|
return os.rename(src, dst) |
|
|
end |
|
|
|
|
|
function _M.remove(P) |
|
|
|
|
|
if (not IS_WINDOWS) and _M.isdir(P) then |
|
|
return nil, "remove method can not remove dirs" |
|
|
end |
|
|
return os.remove(P) |
|
|
end |
|
|
|
|
|
local function splitpath(P) return string.match(P,"^(.-)[\\/]?([^\\/]*)$") end |
|
|
|
|
|
function _M.tmpdir() |
|
|
if IS_WINDOWS then |
|
|
for _, p in ipairs{'TEMP', 'TMP'} do |
|
|
local dir = os.getenv(p) |
|
|
if dir and dir ~= '' then |
|
|
return dir |
|
|
end |
|
|
end |
|
|
end |
|
|
return (splitpath(os.tmpname())) |
|
|
end |
|
|
|
|
|
_M.dir = lfs.dir |
|
|
|
|
|
_M.touch = lfs.touch |
|
|
|
|
|
local function isdots(P) |
|
|
return P == '.' or P == '..' |
|
|
end |
|
|
|
|
|
local foreach_impl |
|
|
|
|
|
local function do_foreach_recurse(base, match, callback, option) |
|
|
local dir_next, dir = lfs.dir(base) |
|
|
for name in dir_next, dir do if not isdots(name) then |
|
|
local path = base .. DIR_SEP .. name |
|
|
if _M.attributes(path,"mode") == "directory" then |
|
|
local ret, err = foreach_impl(path, match, callback, option) |
|
|
if ret or err then |
|
|
if dir then dir:close() end |
|
|
return ret, err |
|
|
end |
|
|
end |
|
|
end end |
|
|
end |
|
|
|
|
|
foreach_impl = function(base, match, callback, option) |
|
|
local tmp, origin_cb |
|
|
if option.delay then |
|
|
tmp, origin_cb, callback = {}, callback, function(base,name,fd) |
|
|
table.insert(tmp, {base,name,fd}) |
|
|
end; |
|
|
end |
|
|
|
|
|
if option.recurse and option.reverse == true then |
|
|
local ok, err = do_foreach_recurse(base, match, callback, option) |
|
|
if ok or err then return ok, err end |
|
|
end |
|
|
|
|
|
local dir_next, dir = lfs.dir(base) |
|
|
for name in dir_next, dir do if option.skipdots == false or not isdots(name) then |
|
|
local path = base .. DIR_SEP .. name |
|
|
local attr = _M.attributes(path) |
|
|
if not attr then return end |
|
|
|
|
|
if (option.skipdirs and attr.mode == "directory") |
|
|
or (option.skipfiles and attr.mode == "file") |
|
|
then else |
|
|
if match(name) then |
|
|
local ret, err = callback(base, name, attr) |
|
|
if ret or err then |
|
|
if dir then dir:close() end |
|
|
return ret, err |
|
|
end |
|
|
end |
|
|
end |
|
|
|
|
|
local can_recurse = (not option.delay) and option.recurse and (option.reverse == nil) |
|
|
if can_recurse and attr.mode == "directory" and not isdots(name) then |
|
|
local ret, err = foreach_impl(path, match, callback, option) |
|
|
if ret or err then |
|
|
if dir then dir:close() end |
|
|
return ret, err |
|
|
end |
|
|
end |
|
|
end end |
|
|
|
|
|
if option.delay then |
|
|
for _, t in ipairs(tmp) do |
|
|
local ok, err = origin_cb(t[1], t[2], t[3]) |
|
|
if ok or err then return ok, err end |
|
|
end |
|
|
end |
|
|
|
|
|
if option.recurse and (not option.reverse) then |
|
|
if option.delay or (option.reverse == false) then |
|
|
return do_foreach_recurse(base, match, origin_cb or callback, option) |
|
|
end |
|
|
end |
|
|
end |
|
|
|
|
|
local function filePat2rexPat(pat) |
|
|
if pat:find("[*?]") then |
|
|
local post = '$' |
|
|
if pat:find("*", 1, true) then |
|
|
if pat:find(".", 1, true) then post = '[^.]*$' |
|
|
else post = '' end |
|
|
end |
|
|
pat = "^" .. pat:gsub("%.","%%."):gsub("%*",".*"):gsub("%?", ".?") .. post |
|
|
else |
|
|
pat = "^" .. pat:gsub("%.","%%.") .. "$" |
|
|
end |
|
|
if IS_WINDOWS then pat = pat:upper() end |
|
|
return pat |
|
|
end |
|
|
|
|
|
local function match_pat(pat) |
|
|
pat = filePat2rexPat(pat) |
|
|
return IS_WINDOWS |
|
|
and function(s) return nil ~= string.find(string.upper(s), pat) end |
|
|
or function(s) return nil ~= string.find(s, pat) end |
|
|
end |
|
|
|
|
|
function _M.foreach(base, callback, option) |
|
|
local base, mask = splitpath(base, DIR_SEP) |
|
|
if mask ~= '' then mask = match_pat(mask) |
|
|
else mask = function() return true end end |
|
|
return foreach_impl(base, mask, function(base, name, fd) |
|
|
return callback(base .. DIR_SEP .. name, fd) |
|
|
end, option or {}) |
|
|
end |
|
|
|
|
|
local attribs = { |
|
|
f = function(base, name, fd) return base..DIR_SEP..name end; |
|
|
p = function(base, name, fd) return base end; |
|
|
n = function(base, name, fd) return name end; |
|
|
m = function(base, name, fd) return fd.mode end; |
|
|
a = function(base, name, fd) return fd end; |
|
|
z = function(base, name, fd) return fd.size end; |
|
|
t = function(base, name, fd) return fd.modification end; |
|
|
c = function(base, name, fd) return fd.change end; |
|
|
l = function(base, name, fd) return fd.access end; |
|
|
} |
|
|
|
|
|
local function make_attrib(str) |
|
|
local t = {} |
|
|
for i = 1, #str do |
|
|
local ch = str:sub(i,i) |
|
|
local fn = attribs[ ch ] |
|
|
if not fn then return nil, 'unknown file attribute: ' .. ch end |
|
|
table.insert(t, fn) |
|
|
end |
|
|
|
|
|
return function(...) |
|
|
local res = {n = #t} |
|
|
for i, f in ipairs(t) do |
|
|
local ok, err = f(...) |
|
|
if ok == nil then return nil, err end |
|
|
table.insert(res, ok) |
|
|
end |
|
|
return res |
|
|
end |
|
|
end |
|
|
|
|
|
function _M.each_impl(option) |
|
|
if not option.file then return nil, 'no file mask present' end |
|
|
local base, mask = splitpath( option.file, DIR_SEP ) |
|
|
if mask ~= '' then mask = match_pat(mask) |
|
|
else mask = function() return true end end |
|
|
|
|
|
local get_params, err = make_attrib(option.param or 'f') |
|
|
if not get_params then return nil, err end |
|
|
local unpack = unpack or table.unpack |
|
|
|
|
|
local filter = option.filter |
|
|
|
|
|
if option.callback then |
|
|
local callback = option.callback |
|
|
|
|
|
local function cb(base, name, fd) |
|
|
local params = assert(get_params(base, name, fd)) |
|
|
if filter and (not filter(unpack(params, 1, params.n))) then return end |
|
|
return callback(unpack(params, 1, params.n)) |
|
|
end |
|
|
|
|
|
return foreach_impl(base, mask, cb, option) |
|
|
else |
|
|
local function cb(base, name, fd) |
|
|
local params = assert(get_params(base, name, fd)) |
|
|
if filter and (not filter(unpack(params, 1, params.n))) then return end |
|
|
coroutine.yield(params) |
|
|
end |
|
|
local co = coroutine.create(function() |
|
|
foreach_impl(base, mask, cb, option) |
|
|
end) |
|
|
return function() |
|
|
local status, params = coroutine.resume(co) |
|
|
if status then if params then return unpack(params, 1, params.n) end |
|
|
else error(params, 2) end |
|
|
end |
|
|
end |
|
|
end |
|
|
|
|
|
local create_each = require "path.findfile".load |
|
|
|
|
|
_M.each = create_each(_M.each_impl) |
|
|
|
|
|
local function match_pat_selftest() |
|
|
|
|
|
local t = { |
|
|
["*.txt"] = { |
|
|
[".txt" ] = true; |
|
|
["1.txt" ] = true; |
|
|
["1.txtdat" ] = true; |
|
|
[".txtdat" ] = false; |
|
|
[".txt.dat" ] = false; |
|
|
[".dat.txt" ] = true; |
|
|
}; |
|
|
["*.txt*"] = { |
|
|
[".txt" ] = true; |
|
|
["1.txt" ] = true; |
|
|
["1.txtdat" ] = true; |
|
|
[".txtdat" ] = true; |
|
|
[".txt.dat" ] = true; |
|
|
[".dat.txt" ] = true; |
|
|
}; |
|
|
["?.txt"] = { |
|
|
[".txt" ] = true; |
|
|
["1.txt" ] = true; |
|
|
["1.txtdat" ] = false; |
|
|
[".txtdat" ] = false; |
|
|
[".txt.dat" ] = false; |
|
|
[".dat.txt" ] = false; |
|
|
}; |
|
|
["1?.txt"] = { |
|
|
[".txt" ] = false; |
|
|
["1.txt" ] = true; |
|
|
["1.txtdat" ] = false; |
|
|
[".txtdat" ] = false; |
|
|
[".txt.dat" ] = false; |
|
|
[".dat.txt" ] = false; |
|
|
}; |
|
|
["1*.txt"] = { |
|
|
[".txt" ] = false; |
|
|
["1.txt" ] = true; |
|
|
["1.txtdat" ] = true; |
|
|
[".txtdat" ] = false; |
|
|
[".txt.dat" ] = false; |
|
|
[".dat.txt" ] = false; |
|
|
}; |
|
|
} |
|
|
|
|
|
local function test_match(pat, t) |
|
|
local cmp = match_pat(pat) |
|
|
for fname, status in pairs(t) do |
|
|
if status ~= cmp(fname) then |
|
|
io.write("Pat: ", pat, " Name: ", fname, " Expected: ", tostring(status), " Got: ", tostring(cmp(fname)), "\n") |
|
|
end |
|
|
end |
|
|
end |
|
|
|
|
|
for k, v in pairs(t) do |
|
|
test_match(k,v) |
|
|
end |
|
|
|
|
|
end |
|
|
|
|
|
return _M |
|
|
end |
