local lfs = require 'lfs'
|
local core = require 'git.core'
|
local deflate = core.deflate
|
local inflate = core.inflate
|
local sha = core.sha
|
|
module(..., package.seeall)
|
|
local BUF_SIZE = 4096
|
|
local dirsep = package.config:sub(1,1)
|
|
-- replaces '/' path separators on Windows with the correct ones ('\\')
|
function correct_separators(path)
|
return path:gsub('/', dirsep)
|
end
|
|
-- joins several path components into a single path, uses system-specific directory
|
-- separator, cleans input, i.e. join_path('a/', 'b', 'c/') => 'a/b/c'
|
function join_path(...)
|
local n = select('#', ...)
|
local args = {...}
|
for i=1,n do
|
args[i] = args[i]:gsub(dirsep..'?$', '')
|
end
|
return table.concat(args, dirsep, 1, n)
|
end
|
|
-- Return the path with the all occurences of '/.' or '\.' (representing
|
-- the current directory) removed.
|
local function remove_curr_dir_dots(path)
|
while path:match(dirsep .. "%." .. dirsep) do -- match("/%./")
|
path = path:gsub(dirsep .. "%." .. dirsep, dirsep) -- gsub("/%./", "/")
|
end
|
return path:gsub(dirsep .. "%.$", "") -- gsub("/%.$", "")
|
end
|
|
-- Return whether the path is a root.
|
local function is_root(path)
|
return path:find("^[%u%U.]?:?[/\\]$")
|
end
|
|
-- Return the path with the unnecessary trailing separator removed.
|
local function remove_trailing(path)
|
if path:sub(-1) == dirsep and not is_root(path) then path = path:sub(1,-2) end
|
return path
|
end
|
|
-- Extract file or directory name from its path.
|
local function extract_name(path)
|
if is_root(path) then return path end
|
|
path = remove_trailing(path)
|
path = path:gsub("^.*" .. dirsep, "")
|
return path
|
end
|
|
-- Return the string 'str', with all magic (pattern) characters escaped.
|
local function escape_magic(str)
|
local escaped = str:gsub('[%-%.%+%[%]%(%)%^%%%?%*%^%$]','%%%1')
|
return escaped
|
end
|
|
-- Return parent directory of the 'path' or nil if there's no parent directory.
|
-- If 'path' is a path to file, return the directory the file is in.
|
function parent_dir(path)
|
path = remove_curr_dir_dots(path)
|
path = remove_trailing(path)
|
|
local dir = path:gsub(escape_magic(extract_name(path)) .. "$", "")
|
if dir == "" then
|
return nil
|
else
|
return remove_trailing(dir)
|
end
|
end
|
|
-- Make a new directory, making also all of its parent directories that doesn't exist.
|
function make_dir(path)
|
if lfs.attributes(path) then
|
return true
|
else
|
local par_dir = parent_dir(path)
|
if par_dir then
|
assert(make_dir(par_dir))
|
end
|
return lfs.mkdir(path)
|
end
|
end
|
|
|
-- Reader class
|
-- adapted from Penlight: https://raw.github.com/stevedonovan/Penlight/master/lua/pl/stringio.lua
|
|
local SR = {}
|
SR.__index = SR
|
|
function SR:_read(fmt)
|
local i,str = self.i,self.str
|
local sz = #str
|
if i > sz then return nil, "past end of file" end
|
local res
|
if fmt == '*l' or fmt == '*L' then
|
local idx = str:find('\n',i) or (sz+1)
|
res = str:sub(i,fmt == '*l' and idx-1 or idx)
|
self.i = idx+1
|
elseif fmt == '*a' then
|
res = str:sub(i)
|
self.i = sz+1
|
elseif fmt == '*n' then
|
local _,i2,i2,idx
|
_,idx = str:find ('%s*%d+',i)
|
_,i2 = str:find ('^%.%d+',idx+1)
|
if i2 then idx = i2 end
|
_,i2 = str:find ('^[eE][%+%-]*%d+',idx+1)
|
if i2 then idx = i2 end
|
local val = str:sub(i,idx)
|
res = tonumber(val)
|
self.i = idx+1
|
elseif type(fmt) == 'number' then
|
res = str:sub(i,i+fmt-1)
|
self.i = i + fmt
|
else
|
error("bad read format",2)
|
end
|
return res
|
end
|
|
function SR:read(...)
|
if select('#',...) == 0 then
|
return self:_read('*l')
|
else
|
local res, fmts = {},{...}
|
for i = 1, #fmts do
|
res[i] = self:_read(fmts[i])
|
end
|
return unpack(res)
|
end
|
end
|
|
function SR:seek(whence,offset)
|
local base
|
whence = whence or 'cur'
|
offset = offset or 0
|
if whence == 'set' then
|
base = 1
|
elseif whence == 'cur' then
|
base = self.i
|
elseif whence == 'end' then
|
base = #self.str
|
end
|
self.i = base + offset
|
return self.i
|
end
|
|
function SR:close() -- for compatibility only
|
end
|
|
--- create a file-like object for reading from a given string.
|
-- @param s The input string.
|
function reader(s)
|
return setmetatable({str=s,i=1},SR)
|
end
|
|
|
-- decompress the file and return a handle to temporary uncompressed file
|
function decompressed(path)
|
local fi = assert(io.open(path, 'rb'))
|
local result = {}
|
|
local z = inflate()
|
repeat
|
local str = fi:read(BUF_SIZE)
|
local data = z(str)
|
if type(data) == 'string' then
|
result[#result+1] = data
|
else print('!!!', data) end
|
until not str
|
fi:close()
|
|
return reader(table.concat(result))
|
end
|
|
-- reads until the byte \0, consumes it and returns the string up to the \0
|
function read_until_nul(f)
|
local t = {}
|
repeat
|
local c = f:read(1)
|
if c and c ~= '\0' then t[#t+1] = c end
|
until not c or c == '\0'
|
if #t > 0 then
|
return table.concat(t)
|
else
|
return nil
|
end
|
end
|
|
-- converts a string to lowercase hex
|
function to_hex(s)
|
return (s:gsub('.', function(c)
|
return string.format('%02x', string.byte(c))
|
end))
|
end
|
|
-- converts a string from hex to binary
|
function from_hex(s)
|
return (s:gsub('..', function(cc)
|
return string.char(tonumber(cc, 16))
|
end))
|
end
|
|
-- always returns readable (hex) hash
|
function readable_sha(s)
|
if #s ~= 40 then return to_hex(s)
|
else return s end
|
end
|
|
-- always returns binary hash
|
function binary_sha(s)
|
if #s ~= 20 then return from_hex(s)
|
else return s end
|
end
|
|
function object_sha(data, len, type)
|
local header = type .. ' ' .. len .. '\0'
|
local res = sha(header .. data)
|
return res
|
end
|
|
function deflate(data)
|
local c = deflate()
|
return c(data, "finish")
|
end
|
