lpath is a lfs-like Lua module to handle path, file system and file informations.

This module is inspired by Python's os.path and pathlib module. It split into 4 parts:

• path: main module, pathlib style path operations.
• path.fs: fs specific operations, folder walking, file operations, etc.
• path.info: some constants about path literals.
• path.env set/get environment variables, and expand env vars in path.

All routines in this module which accept ... for parameters means you could pass any count of string as arguments. All string will joined into a single path, just as pass all arguments to path(...), and pass the resulting path string to the routine.

All routines may returns nil, error for error case. if you want raise error to Lua, use assert(...) for routines.

These functions will return a iterator that yields filename, type pair. The type could be:

• "file" a file name
• "dir" a dir the will not walk into it.
• "in" a dir that will walk into it, i.e. the next iteration will yields the content in this folder.
• "out" a dir that completed walk.

If you pass a number argument as the last argument of fs.scandir()/fs.glob(), this number argument will be treat as the limit of walking. e.g. fs.scandir("foo", 1) will walks into all subdirectory/files in "foo", but not contents in subdirectories.

-- assume folder "foo" has this struture:
-- - foo
--   |- bar
--      |- bar.txt
--   |- foo.txt
-- the code below:
for fn, ty in fs.scandir("foo", 1) do
  print(fn, ty)
end
-- will prints:
-- foo in
-- bar dir
-- foo.txt file
-- foo out

fs.glob() accepts a path thats contains patterns in it. But patterns in drive part will be ignored. e.g. the pattern likes "*:/foo.txt" in Windows will yields empty results.

A empty pattern ("") is not allowed.

If a pattern contains "**", the fs.glob() will walks into all current subdirectories to find a match after "**", e.g. "**/*.txt" will yields all .txt files in any levels of subdirectories of current folder.

If the pattern ends with "**", all subdirectories, but not files, will returnd.

Some examples:

-- assume same struture of folder "foo" above.
local function collect(pattern) do
    local t = {}
    for fn in fs.glob(pattern) do
      t[#t+1] = fn
    end
end
collect "*.txt"    -- returns {"foo/foo.txt"}
collect "**/*.txt" -- returns {"foo/foo.txt", "foo/bar/bar.txt"}
collect "**"       -- returns {"foo/bar"}

path.info has several constants about current system:

• platform:
  • "windows"
  • "linux"
  • "macosx"
  • "android"
  • "posix"
• sep: separator of directory on current system. It's "\\" on Windows, "/" otherwise.
• altsep: the alternative directory separator, always "/".
• curdir: the current directory, usually ".".
• pardir: the parent directory, usually "..".
• devnull: the null device file, "nul" on Windows, "dev/null" otherwise
• extsep: extension separator, usually ".".
• pathsep: the separator for $PATH, ";" on Windows, otherwise ":".

Same as Lua's License.

See here: http://lua-users.org/wiki/BuildingModules