MOOSE/Utils/luarocks/systree/share/lua/5.1/pl/path.lua

--- Path manipulation and file queries. <br>
-- This is modelled after Python's os.path library (11.1)
-- @class module
-- @name pl.path

-- imports and locals
local _G = _G
local sub = string.sub
local getenv = os.getenv
local tmpnam = os.tmpname
local attributes, currentdir, link_attrib
local package = package
local io = io
local append = table.insert
local ipairs = ipairs
local utils = require 'pl.utils'
local assert_arg,assert_string,raise = utils.assert_arg,utils.assert_string,utils.raise

--[[
module ('pl.path',utils._module)
]]

local path, attrib

if _G.luajava then
    path = require 'pl.platf.luajava'
else
    path = {}

    local res,lfs = _G.pcall(_G.require,'lfs')
    if res then
        attributes = lfs.attributes
        currentdir = lfs.currentdir
        link_attrib = lfs.symlinkattributes
    else
        error("pl.path requires LuaFileSystem")
    end

    attrib = attributes
    path.attrib = attrib
    path.link_attrib = link_attrib
    path.dir = lfs.dir
    path.mkdir = lfs.mkdir
    path.rmdir = lfs.rmdir
    path.chdir = lfs.chdir

    --- is this a directory?
    -- @param P A file path
    function path.isdir(P)
        if P:match("\\$") then
            P = P:sub(1,-2)
        end
        return attrib(P,'mode') == 'directory'
    end

    --- is this a file?.
    -- @param P A file path
    function path.isfile(P)
        return attrib(P,'mode') == 'file'
    end

    -- is this a symbolic link?
    -- @param P A file path
    function path.islink(P)
        if link_attrib then
            return link_attrib(P,'mode')=='link'
        else
            return false
        end
    end

    --- return size of a file.
    -- @param P A file path
    function path.getsize(P)
        return attrib(P,'size')
    end

    --- does a path exist?.
    -- @param P A file path
    -- @return the file path if it exists, nil otherwise
    function path.exists(P)
        return attrib(P,'mode') ~= nil and P
    end

    --- Return the time of last access as the number of seconds since the epoch.
    -- @param P A file path
    function path.getatime(P)
        return attrib(P,'access')
    end

    --- Return the time of last modification
    -- @param P A file path
    function path.getmtime(P)
        return attrib(P,'modification')
    end

    ---Return the system's ctime.
    -- @param P A file path
    function path.getctime(P)
        return path.attrib(P,'change')
    end
end


local function at(s,i)
    return sub(s,i,i)
end

path.is_windows = utils.dir_separator == '\\'

local other_sep
-- !constant sep is the directory separator for this platform.
if path.is_windows then
    path.sep = '\\'; other_sep = '/'
    path.dirsep = ';'
else
    path.sep = '/'
    path.dirsep = ':'
end
local sep,dirsep = path.sep,path.dirsep

--- are we running Windows?
-- @class field
-- @name path.is_windows

--- path separator for this platform.
-- @class field
-- @name path.sep

--- separator for PATH for this platform
-- @class field
-- @name path.dirsep

--- given a path, return the directory part and a file part.
-- if there's no directory part, the first value will be empty
-- @param P A file path
function path.splitpath(P)
    assert_string(1,P)
    local i = #P
    local ch = at(P,i)
    while i > 0 and ch ~= sep and ch ~= other_sep do
        i = i - 1
        ch = at(P,i)
    end
    if i == 0 then
        return '',P
    else
        return sub(P,1,i-1), sub(P,i+1)
    end
end

--- return an absolute path.
-- @param P A file path
function path.abspath(P)
    assert_string(1,P)
    if not currentdir then return P end
    P = P:gsub('[\\/]$','')
    local pwd = currentdir()
    if not path.isabs(P) then
        return path.join(pwd,P)
    elseif path.is_windows and at(P,2) ~= ':' and at(P,2) ~= '\\' then
        return pwd:sub(1,2)..P
    else
        return P
    end
end

--- given a path, return the root part and the extension part.
-- if there's no extension part, the second value will be empty
-- @param P A file path
function path.splitext(P)
    assert_string(1,P)
    local i = #P
    local ch = at(P,i)
    while i > 0 and ch ~= '.' do
        if ch == sep or ch == other_sep then
            return P,''
        end
        i = i - 1
        ch = at(P,i)
    end
    if i == 0 then
        return P,''
    else
        return sub(P,1,i-1),sub(P,i)
    end
end

--- return the directory part of a path
-- @param P A file path
function path.dirname(P)
    assert_string(1,P)
    local p1,p2 = path.splitpath(P)
    return p1
end

--- return the file part of a path
-- @param P A file path
function path.basename(P)
    assert_string(1,P)
    local p1,p2 = path.splitpath(P)
    return p2
end

--- get the extension part of a path.
-- @param P A file path
function path.extension(P)
    assert_string(1,P)
    local p1,p2 = path.splitext(P)
    return p2
end

--- is this an absolute path?.
-- @param P A file path
function path.isabs(P)
    assert_string(1,P)
    if path.is_windows then
        return at(P,1) == '/' or at(P,1)=='\\' or at(P,2)==':'
    else
        return at(P,1) == '/'
    end
end

--- return the P resulting from combining the two paths.
-- if the second is already an absolute path, then it returns it.
-- @param p1 A file path
-- @param p2 A file path
function path.join(p1,p2)
    assert_string(1,p1)
    assert_string(2,p2)
    if path.isabs(p2) then return p2 end
    local endc = at(p1,#p1)
    if endc ~= path.sep and endc ~= other_sep then
        p1 = p1..path.sep
    end
    return p1..p2
end

--- normalize the case of a pathname. On Unix, this returns the path unchanged;
--  for Windows, it converts the path to lowercase, and it also converts forward slashes
-- to backward slashes.
-- @param P A file path
function path.normcase(P)
    assert_string(1,P)
    if path.is_windows then
        return (P:lower():gsub('/','\\'))
    else
        return P
    end
end

--- normalize a path name.
--  A//B, A/./B and A/foo/../B all become A/B.
-- @param P a file path
function path.normpath (P)
    assert_string(1,P)
    if path.is_windows then
        P = P:gsub('/','\\')
        return (P:gsub('[^\\]+\\%.%.\\',''):gsub('\\%.?\\','\\'))
    else
        return (P:gsub('[^/]+/%.%./',''):gsub('/%.?/','/'))
    end
end


--- Replace a starting '~' with the user's home directory.
-- In windows, if HOME isn't set, then USERPROFILE is used in preference to
-- HOMEDRIVE HOMEPATH. This is guaranteed to be writeable on all versions of Windows.
-- @param P A file path
function path.expanduser(P)
    assert_string(1,P)
    if at(P,1) == '~' then
        local home = getenv('HOME')
        if not home then -- has to be Windows
            home = getenv 'USERPROFILE' or (getenv 'HOMEDRIVE' .. getenv 'HOMEPATH')
        end
        return home..sub(P,2)
    else
        return P
    end
end


---Return a suitable full path to a new temporary file name.
-- unlike os.tmpnam(), it always gives you a writeable path (uses %TMP% on Windows)
function path.tmpname ()
    local res = tmpnam()
    if path.is_windows then res = getenv('TMP')..res end
    return res
end

--- return the largest common prefix path of two paths.
-- @param path1 a file path
-- @param path2 a file path
function path.common_prefix (path1,path2)
    assert_string(1,path1)
    assert_string(2,path2)
    -- get them in order!
    if #path1 > #path2 then path2,path1 = path1,path2 end
    for i = 1,#path1 do
        local c1 = at(path1,i)
        if c1 ~= at(path2,i) then
            local cp = path1:sub(1,i-1)
            if at(path1,i-1) ~= sep then
                cp = path.dirname(cp)
            end
            return cp
        end
    end
    if at(path2,#path1+1) ~= sep then path1 = path.dirname(path1) end
    return path1
    --return ''
end


--- return the full path where a particular Lua module would be found.
-- Both package.path and package.cpath is searched, so the result may
-- either be a Lua file or a shared libarary.
-- @param mod name of the module
-- @return on success: path of module, lua or binary
-- @return on error: nil,error string
function path.package_path(mod)
    assert_string(1,mod)
    local res
    mod = mod:gsub('%.',sep)
    res = package.searchpath(mod,package.path)
    if res then return res,true end
    res = package.searchpath(mod,package.cpath)
    if res then return res,false end
    return raise 'cannot find module on path'
end


---- finis -----
return path