rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/git/repo.lua

@@ -0,0 +1,283 @@
+local util = require 'git.util'
+local objects = require 'git.objects'
+local core = require 'git.core'
+local pack = require 'git.pack'
+
+local join_path = util.join_path
+local decompressed = util.decompressed
+local read_until_nul = util.read_until_nul
+local to_hex = util.to_hex
+local object_sha = util.object_sha
+local readable_sha = util.readable_sha
+
+local deflate = core.deflate
+
+local lfs = require 'lfs'
+local assert, error, io, ipairs, print, os, setmetatable, string, table =
+	assert, error, io, ipairs, print, os, setmetatable, string, table
+
+module(...)
+
+Repo = {}
+Repo.__index = Repo
+
+-- retrieves an object identified by `sha` from the repository or its packs
+-- returns a file-like object (supports 'read', 'seek' and 'close'), the size
+-- of the object and its type
+-- errors when the object does not exist
+function Repo:raw_object(sha)
+	-- first, look in 'objects' directory
+	-- first byte of sha is the directory, the rest is name of object file
+	sha = readable_sha(sha)
+	local dir = sha:sub(1,2)
+	local file = sha:sub(3)
+	local path = join_path(self.dir, 'objects', dir, file)
+
+	if not lfs.attributes(path, 'size') then
+		-- then, try to look in packs
+		for _, pack in ipairs(self.packs) do
+			local obj, len, typ = pack:get_object(sha)
+			if obj then
+				return obj, len, typ
+			end
+		end
+		error('Object not found in object neither in packs: '..sha)
+	else		
+		-- the objects are zlib compressed
+		local f = decompressed(path)
+
+		-- retrieve the type and length - <type> SP <len> \0 <data...>
+		local content = read_until_nul(f)
+		local typ, len = content:match('(%w+) (%d+)')
+
+		return f, len, typ
+	end
+end
+
+--- Store a new object into the repository in `objects` directory.
+-- @param data A string containing the contents of the new file.
+-- @param len The length of the data.
+-- @param type One of 'commit', 'blob', 'tree', 'tag'
+function Repo:store_object(data, len, type)
+	local sha = readable_sha(object_sha(data, len, type))
+	local dir = sha:sub(1,2)
+	local file = sha:sub(3)
+	util.make_dir(join_path(self.dir, 'objects', dir))
+	local path = join_path(self.dir, 'objects', dir, file)
+	local fo = assert(io.open(path, 'wb'))
+	local header = type .. ' ' .. len .. '\0'
+	local compressed = deflate()(header .. data, "finish")
+	fo:write(compressed)
+	fo:close()
+end
+
+local function resolvetag(f)
+	local tag
+	local line = f:read()
+	while line do
+		tag = line:match('^object (%x+)$')
+		if tag then break end
+		line = f:read()
+	end
+	f:close()
+	return tag
+end
+
+function Repo:commit(sha)
+	local f, len, typ = self:raw_object(sha)
+	while typ == 'tag' do
+		sha = assert(resolvetag(f), 'could not parse tag for '..readable_sha(sha))
+		f, len, typ = self:raw_object(sha)
+	end
+	assert(typ == 'commit', string.format('%s (%s) is not a commit', sha, typ))
+
+	local commit = { id = sha, repo = self, stored = true, parents = {} }
+	repeat
+		local line = f:read()
+		if not line then break end
+
+		local space = line:find(' ') or 0
+		local word = line:sub(1, space - 1)
+		local afterSpace = line:sub(space + 1)
+
+		if word == 'tree' then
+			commit.tree_sha = afterSpace
+		elseif word == 'parent' then
+			table.insert(commit.parents, afterSpace)
+		elseif word == 'author' then
+			commit.author = afterSpace
+		elseif word == 'committer' then
+			commit.committer = afterSpace
+		elseif commit.message then
+			table.insert(commit.message, line)
+		elseif line == '' then
+			commit.message = {}
+		end
+	until false -- ends with break
+	f:close()
+
+	commit.message = table.concat(commit.message, '\n')
+
+	return setmetatable(commit, objects.Commit)
+end
+
+function Repo:tree(sha)
+	local f, len, typ = self:raw_object(sha)
+	assert(typ == 'tree', string.format('%s (%s) is not a tree', sha, typ))
+
+	local tree = { id = sha, repo = self, stored = true, _entries = {} }
+
+	while true do
+		local info = read_until_nul(f)
+		if not info then break end
+		local entry_sha = to_hex(f:read(20))
+		local mode, name = info:match('^(%d+)%s(.+)$')
+		local entry_type = 'blob'
+		if mode == '40000' then
+			entry_type = 'tree'
+		elseif mode == '160000' then
+			entry_type = 'commit'
+		end
+		tree._entries[name] = { mode = mode, id = entry_sha, type = entry_type }
+	end
+
+	f:close()
+
+	return setmetatable(tree, objects.Tree)
+end
+
+-- retrieves a Blob
+function Repo:blob(sha)
+	local f, len, typ = self:raw_object(sha)
+	f:close() -- can be reopened in Blob:content()
+
+	assert(typ == 'blob', string.format('%s (%s) is not a blob', sha, typ))
+	return setmetatable({ 
+		id = sha,
+		len = len,
+		repo = self,
+		stored = true }, objects.Blob)
+end
+
+function Repo:head()
+	return self:commit(self.refs.HEAD)
+end
+
+function Repo:has_object(sha)
+	local dir = sha:sub(1,2)
+	local file = sha:sub(3)
+	local path = join_path(self.dir, 'objects', dir, file)
+
+	if lfs.attributes(path, 'size') then return true end
+
+	for _, pack in ipairs(self.packs) do
+		local has = pack:has_object(sha)
+		if has then return true end
+	end
+
+	return false
+end
+
+function Repo:checkout(sha, target)
+	if not target then target = self.workDir end
+	assert(target, 'target directory not specified')
+
+	local commit = self:commit(sha)
+	commit:checkout(target)
+
+	-- if the repo was checked out using the deepen command (one level of history only)
+	-- mark the commit's parent as shalow, that is it has no history
+	if self.isShallow then
+		-- if it has a parent, mark it shallow
+		if commit.parents[1] then
+			local f = assert(io.open(self.dir .. '/shallow', "w"))
+			f:write(commit.parents[1], '\n')
+			f:close()
+		end
+	end
+end
+
+function Repo:close()
+	for _, pack in ipairs(self.packs) do
+		pack:close()
+	end
+end	
+
+function create(dir)
+	if not dir:match('%.git.?$') then
+		dir = join_path(dir, '.git')
+	end
+	
+	util.make_dir(dir)
+	util.make_dir(dir .. '/branches')
+	util.make_dir(dir .. '/hooks')
+	util.make_dir(dir .. '/info')	
+	util.make_dir(dir .. '/objects/info')
+	util.make_dir(dir .. '/objects/pack')
+	util.make_dir(dir .. '/refs/heads')
+	util.make_dir(dir .. '/refs/tags')
+	util.make_dir(dir .. '/refs/remotes')
+
+	do
+		local f = assert(io.open(dir .. "/HEAD", "w"))
+		f:write("ref: refs/heads/master\n")
+		f:close()
+	end
+
+	local refs = {}
+	local packs = {}
+
+	return setmetatable({
+		dir = dir,
+		refs = refs,
+		packs = packs,
+	}, Repo)
+end
+
+-- opens a repository located in working directory `dir` or directly a .git repo
+function open(dir)
+	local workDir = dir
+	if not dir:match('%.git.?$') then
+		dir = join_path(dir, '.git')
+	else
+		workDir = nil -- no working directory, working directly with repo
+	end
+
+	local refs = {}
+	for _,d in ipairs{'refs/heads', 'refs/tags'} do
+		for fn in lfs.dir(join_path(dir, d)) do
+			if fn ~= '.' and fn ~= '..' then
+				local path = join_path(dir, d, fn)
+				local f = assert(io.open(path), 'rb')
+				local ref = f:read()
+				refs[join_path(d, fn)] = ref
+				f:close()
+			end
+		end
+	end
+
+	local packs = {}
+	for fn in lfs.dir(join_path(dir, 'objects/pack')) do
+		if fn:match('%.pack$') then
+			local path = join_path(dir, 'objects/pack', fn)
+			table.insert(packs, pack.open(path))
+		end
+	end
+
+	local head = io.open(join_path(dir, 'HEAD'), 'rb')
+	if head then
+		local src = head:read()
+		local HEAD = src:match('ref: (.-)$')
+		refs.HEAD = refs[HEAD]
+		head:close()
+	end
+
+	return setmetatable({
+		dir = dir,
+		workDir = workDir,
+		refs = refs,
+		packs = packs,
+	}, Repo)
+end
+
+return Repo

data/vendor/lua/lib/lua/git/util.lua

@@ -0,0 +1,233 @@
+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