Tamar 0.7.2 → 0.7.3

data/src/luadist/dist/log.lua

@@ -0,0 +1,37 @@
+--- LuaDist simple message logger
+-- Peter Drahoš, Peter Kapec, LuaDist Project, 2010
+
+--- Very simple log system.
+-- 2DO: change to LuaLogging on next version.
+-- write - write a log line
+-- message - write and optionally display a message
+
+module ("dist.log", package.seeall)
+
+local lfs 		= require "lfs"
+local config	= require "dist.config"
+
+-- Profile to store info in
+lfs.mkdir(config.temp)
+local log = assert(io.open(config.log, "a"), "Could not create log file!")
+
+--- Display and log a message
+function message(...)
+	if config.message then config.message(...) end
+	return write(...)
+end
+
+--- Write a line to log
+function write(...)
+
+	local args = ...
+	if type(...) == "string" then args = { ... } end
+	if type(args) ~= "table" then return nil end
+
+	log:write(os.date("%c", os.time()) .. ":: ")
+	for i = 1, #args do
+		log:write(tostring(args[i]) .. " ")
+	end
+	log:write("\n")
+	log:flush()
+end

data/src/luadist/dist/manifest.lua

@@ -0,0 +1,204 @@
+--- LuaDist manifest specific functions including checks
+-- Peter Drahoš, Peter Kapec, LuaDist Project, 2010
+
+--- The purpose of this module is to check and collect dist manifests.
+-- There are three functions provided:
+-- make - Generates manifest for local directory
+-- get - Gets sorted manifest from URI, this uses make for local paths. For remote directories it requires dist.manifest file to be present.
+-- info - Loads and/or corrects and checks dist.info contents
+-- Dists and manifests are simply arrays of collected dist.info files.
+
+module ("dist.manifest", package.seeall)
+
+local log		= require "dist.log"
+local fetch 	= require "dist.fetch"
+local persist 	= require "dist.persist"
+local sys 		= require "dist.sys"
+local config 	= require "dist.config"
+local dep		= require "dist.dep"
+
+local function couldBeDistFile(path)
+	return (path:match"%.dist$" or path:match"%.zip$") and
+	       sys.isFile(path)
+end
+
+--- Collect and sort dists in a directory.
+-- @param dir string: Directory to get manifest from.
+-- @return dists, log: Dists in the directory and log message.
+function make(dir)
+	assert(type(dir) == "string", "manifest.make: argument 'dir' not a string.")
+
+	-- Collection
+	local dists
+	
+	for id, file in pairs(sys.dir(dir) or {}) do
+		local path = sys.path(dir, file)
+		-- Try to load dist.info in case the file is expanded dist directory, then try loading it from the file using unzip
+		local dist =
+		    persist.load(sys.path(path, "dist.info")) or
+		    couldBeDistFile(path) and
+		        persist.loadText(sys.getZipFile(path, "*/dist.info") or "fail")
+		-- note: couldBeDistFile test avoids calling unnecessarily calling
+		-- getZipFile, which requires io.popen and unzip, which may be
+		-- unavailable in the bootstrapping Lua.
+		
+		-- We have identified a dist
+		if dist then
+			-- Test it
+			local dist, err = info(dist)
+			if dist then
+				-- Collect the dist
+				dists = dists or {}
+				dist.path = file
+				table.insert(dists, dist)
+			else
+				-- Log warnings
+				log.message("Warning, skipped malformed dist.info for file: ", file, "err:", err)
+			end
+		-- Recursively traverse subdirectory
+		elseif sys.isDir(path) then
+			local ret = make(path)
+			for _,v in pairs(ret or {}) do
+				dists = dists or {}
+				v.path = file .. "/" .. v.path
+				table.insert(dists, v)
+			end
+		end
+	end
+	if not dists then return nil, "No dists found in directory " .. dir end
+	return dists, "Generated manifest for directory" .. dir
+end
+
+--- Get or generate repository contents from URI.
+-- @param url string: URL to load the dist.manifest from. In case file:// is used generate the manifest.
+-- @return dists, log: Returns true on success and nil and error message on failure.
+function get(src, variables)
+	assert(type(src) == "string", "manifest:get, argument 'url' is not a string." )
+	
+	-- If the src is local then make the manifest
+	local dir = src:gsub("^file://","")
+	local dists
+
+    -- If src points to a unpacked dist
+	if sys.isFile(sys.path(src, "dist.info")) then
+	    local dist = info(sys.path(src, "dist.info"))
+	    if dist then dists = { dist } end
+	-- If src points to a dir
+	elseif sys.isDir(dir) then
+		dists = make(dir)
+	-- Try collecting from manifest, assuming non-local reporitory
+	else
+		local manifest = fetch.get(sys.path(src, "dist.manifest"))
+		if not manifest then return nil, "Could not obtain manifest for " .. src end
+		dists = persist.loadText(manifest)
+	end
+
+	-- Sort by name and version
+	if not dists then return nil, "No suitable dists found in " .. src end
+
+	-- Check every dist
+	local checked 
+	for i = 1, #dists do
+		local dist, err = info(dists[i])
+		if dist then
+			-- Dist is ok
+			checked = checked or {}
+			if not string.match(dist.path, "^http://") then 
+				dist.path = sys.path(src:gsub("file://",""), dist.path)
+			end
+			table.insert(checked, dist)
+		else
+			-- Malformed dist
+			local name = tostring(dist.name) .. " " .. tostring(dist.version)
+			log.message("Warning, skipped malformed dist.info (" .. name .. ") from:", src, "err:", err)
+		end
+	end
+	if not checked then return nil, "No suitable dists found in " .. src end
+
+	table.sort(checked, function(a, b) 
+		-- If names match
+		if a.name == b.name then
+			-- When versions match
+			if a.version == b.version then
+				-- Prefer Universal arch
+				if a.arch == b.arch then
+					-- Prefer source arch
+					if a.type == "source" then return false end
+				end
+				if a.arch == "Universal" then return false end
+			end
+			return dep.compareVersions(a.version ,b.version)
+		end
+		return a.name < b.name
+	end)
+	return checked, "Succesfuly obtained dists from " .. src
+end
+
+--- Check names in table, used in info checks.
+-- @param table: Table to check names in.
+-- @return ok, err: Returns true if everything is ok. In case of error nil and the malformed entry is returned.
+local function checkNames(table)
+    for k, v in pairs(table) do
+        if type(v) == "string" then
+            local name, const = dep.split(v)
+            if not name then return nil, v end
+        elseif type(v) == "table" then
+            return checkNames(v)
+        else
+            return nil, "unknown entry"
+        end
+    end
+    return true
+end
+
+--- Load and check info from file or check info table
+-- @param dist string or table: Path to dist.info or info table to check.
+-- @return info, log: Table containing loaded and checked info or nil and log message.
+function info(dist)
+	assert(type(dist) == "string" or type(dist) == "table", "manifest:info, argument 'dist' is not a string or table." )
+
+	-- Load the info if needed from a file
+	if type(dist) == "string" then
+		dist = persist.load(dist)
+		if not dist then return nil, "manifest.info: Failed loading dist.info from", dist end
+		return info(dist), "manifest.info: Succesfully loaded dist.info from", dist
+	end
+
+	-- Add arch-type if not present
+	dist.arch = dist.arch or "Universal"
+	dist.type = dist.type or "source"
+
+	
+	-- Check the info entries
+	if type(dist.name) ~= "string" then return nil, "Info does not contain valid name." end
+	if not dist.name:match("[%l%d%.%:%_%-]+") then return nil, "Info info entry 'name' contains invalid characters" end
+	if type(dist.version) ~= "string" then return nil, "Info does not contain valid version." end
+	if not dist.version:match("[%l%d%.%:%_%-]+") then return nil, "Info entry 'version' contains invalid characters" end
+	if type(dist.arch) ~= "string" then return nil, "Info does not contain valid architecture." end
+	if not dist.arch:match("[%a%d]") then return nil, "Info entry 'arch' contains invalid characters." end
+	if type(dist.type) ~= "string" then return nil, "Info does not contain valid type." end
+	if not dist.type:match("[%a%d]") then return nil, "Info entry 'type' contains invalid characters." end
+	
+	-- Optional
+	if dist.desc and type(dist.desc) ~= "string" then return nil, "Info does not contain valid description." end
+	if dist.author and type(dist.author) ~= "string" then return nil, "Info does not contain valid author." end
+	if dist.maintainer and type(dist.maintainer) ~= "string" then return nil, "Info does not contain valid maintainer." end
+	if dist.url and type(dist.url) ~= "string" then return nil, "Info does not contain valid url." end
+	if dist.license and type(dist.license) ~= "string" then return nil, "Info does not contain valid license." end
+	if dist.depends and type(dist.depends) ~= "table" then return nil, "Info does not contain valid dependencies." end
+
+	-- Check dependency format, swap for arch type specific id needed
+	local ok, err = checkNames(dist.depends or {})
+	if not ok then return nil, "Dependencies contain malformed entry: " .. err end
+	
+	-- Same for conflicts
+	local ok, err = checkNames(dist.conflicts or {})
+	if not ok then return nil, "Conflicts contain malformed entry: " .. err end
+
+    -- And provides
+	local ok, err = checkNames(dist.provides or {})
+	if not ok then return nil, "Provides contain malformed entry: " .. err end
+	
+	-- Return, no log since it would spam the log file alot
+	return dist, "Contents of dist is valid."
+end

data/src/luadist/dist/package.lua

@@ -0,0 +1,271 @@
+--- LuaDist package specific functions
+-- Peter Drahoš, Peter Kapec, LuaDist Project, 2010
+
+--- Package handling functions.
+-- This module deals with packages, these are unpacked dists in LuaDist terminology
+-- The following functions are provided:
+-- unpack - fetch and unpack a dist
+-- build - compile a source dist
+-- deploy - install a dist into deployment
+-- pack - create dist from package
+-- delete - delete package
+
+module ("dist.package", package.seeall)
+
+local config 	= require "dist.config"
+local fetch 	= require "dist.fetch"
+local persist 	= require "dist.persist"
+local sys 		= require "dist.sys"
+local manif 	= require "dist.manifest"
+local log	    = require "dist.log"
+
+--- Fetch and unpack zip/dist from URL into dest directory.
+-- @param url string: Local packed dist or URL to fetch dist from.
+-- @param dest string: Destination to unpack contents into, nil for temp directory.
+-- @return path, log: Unpacked dist path or nil and log.
+function unpack(url, dest)
+	-- Make sure dest is set up properly
+	dest = sys.path(dest) or config.temp
+
+	-- Check types
+	assert(type(url)=="string", "package.unpack: Argument 'url' is not a string.")
+	assert(type(dest)=="string", "package.unpack: Argument 'dest' is not a string.")	
+
+	-- Setup destination
+	local name = url:match("([^/]+)%.[^%.]+$")
+	if not name then return nil, "Could not determine dist name from " .. url end
+	local pkg = sys.path(dest, name)
+	local dist = pkg .. ".dist"
+
+	-- If the files already exist
+	if sys.exists(pkg) then return pkg, "Skipped unpack, destination " .. dest .. " exists." end
+	
+	-- Download if needed 
+	if not sys.exists(dist) then
+		-- Download from URL or local path. Fetch handles this
+		dist = fetch.download(url)
+		if not dist then return nil, "Failed to download " .. url end
+	end
+	
+	-- Unzip
+	local ok = sys.unzip(dist, pkg)
+	if not ok then return nil, "Failed to unzip " .. dist .. " to " .. pkg end
+	
+	-- Cleanup
+	if not config.debug then sys.delete(dist) end
+	
+	return pkg, "Unpacked " .. url .. " to " .. pkg
+end
+
+--- Build, deploy and test a source dist using CMake.
+-- @param dist string: Directory of the source dist to build.
+-- @param variables: Table containing optional CMake parameters.
+-- @return path, log: Returns temporary directory the dist was build into and log message.
+function build(dist, depl, variables)
+	-- Make sure deployment is always set up
+	depl = sys.path(depl) or config.root
+	
+	assert(type(dist)=="string", "package.build: Arument 'dist' is not a string.")
+	assert(type(depl)=="string", "package.build: Argument 'depl' is not a string.")
+	assert(type(variables)=="table", "package.build: Argument 'variables' is not a table.")
+
+	-- Load dist info
+	local info = manif.info(sys.path(dist, "dist.info"))
+	if not info then return nil, "Directory " .. dist .. " does not contain valid dist.info." end
+	
+	-- Prepare temporary directory and build directory
+	local install = sys.path(config.temp,info.name .. "-" .. info.version .. "-" .. config.arch .. "-" .. config.type)
+	local build = sys.path(config.temp,info.name .. "-" .. info.version .. "-CMake-build")
+	sys.makeDir(install)
+	sys.makeDir(build)
+
+	-- Prepare CMackeCache
+	variables["CMAKE_INSTALL_PREFIX"] = install
+	
+	local cache = assert(io.open(build..'/cache.cmake', "w"), "Could not create cache file.")
+	for k,v in pairs(variables) do
+		cache:write('SET('..k..' "' .. tostring(v) ..'" CACHE STRING "" FORCE)\n')
+	end
+	cache:close()
+
+	-- Determine build commands
+	local make = config.make
+	local cmake = config.cmake
+	if config.debug then 
+		make = config.makeDebug 
+		cmake = config.cmakeDebug
+	end
+	
+	-- Build
+	local ok = sys.execute("cd " .. sys.Q(build) .. " && " .. cmake .. " -C cache.cmake " .. sys.Q(dist))
+	if not ok then return nil, "CMake failed pre-cmake script in directory " .. build end
+	local ok = sys.execute("cd " .. sys.Q(build) .. " && " .. make)
+	if not ok then return nil, "CMake failed building in directory " .. build end
+
+	-- Save info
+	info.arch = config.arch
+	info.type = config.type
+	local ok = persist.save(sys.path(install, "dist.info"), info  )
+	if not ok then return nil, "Cannot wite dist.info to" .. fullDist end
+
+	-- Deploy the dist
+	local ok, err = deploy(install, depl)
+	if not ok then return nil, err end
+
+	-- Clean up
+	if not config.debug then sys.delete(build) sys.delete(install) end
+	
+	return install, "Successfully built dist in " .. install
+end
+
+--- Deploy dist into deployment directory.
+-- @param dist string: Directory of the dist to deploy.
+-- @param depl string: Deployment directory nil for default.
+-- @return ok, log: Returns true on success and log message.
+function deploy(dist, depl)
+	-- Make sure deployment is always set up
+	depl = sys.path(depl) or config.root
+	
+	assert(type(dist)=="string", "package.deploy: Argument 'dist' is not a string.")
+	assert(type(depl)=="string", "package.deploy: Argument 'depl' is not a string.")
+
+	-- Load dist info
+	local info = manif.info(sys.path(dist, "dist.info"))
+	if not info then return nil, "Directory " .. dist .. " does not contain valid dist.info" end
+
+	-- Relative and full path to dist deployment
+	local distRel = config.dists .. "/" .. info.name .. "-" .. info.version
+	local distPath = sys.path(depl, distRel)
+    
+    -- If we are deploying a dist into itself
+    if distPath == dist then return 
+        true, "Skipping, already deployed"
+    end
+
+	-- Copy to install dir
+	sys.makeDir(depl)
+	sys.makeDir(distPath)
+	
+	-- Collect files to process
+	local files = sys.list(dist)
+
+	-- Simple copy deployment
+	for i = 1, #files do
+		local file = files[i]
+		if file~="dist.info" then
+			local path = sys.path(dist, file)
+			-- Create directory in depl
+			if sys.isDir(path) then
+				local ok, err = sys.makeDir(sys.path(depl, file))
+				if not ok then return nil, "Failed to install " .. dist .. "/" .. file .. " to " .. depl end
+			-- Copy files to depl
+			else
+				local ok, err = sys.copy(sys.path(dist, file), sys.path(depl, file))
+				if not ok then return nil, "Failed to install " .. dist .. "/" .. file .. " to " .. depl end
+			end
+		end
+	end		
+	
+	-- Modify and save dist.info
+	info.files = files
+
+	local ok = persist.save(sys.path(distPath, "dist.info"), info)
+	if not ok then return nil, "Cannot wite dist.info to" .. distPath end
+	
+	return true, "Successfully deployed dist to " .. depl
+end
+
+--- Pack a package to create a dist.
+-- @param dist string: deployed dist to pack.
+-- @param depl string: deployment dir to pack from.
+-- @param dir string: Optional destination for the dist, current directory will be used by default.
+-- @return ok, log: Returns success and log message.
+function pack(dist, depl, dir)
+	depl = depl or dist
+	assert(type(dist)=="string", "package.pack: Argument 'dist' is not a string.")
+	assert(not dir or type(dir)=="string", "package.pack: Argument 'dir' is no a string.")
+	if not dir then dir = sys.curDir() end
+
+	-- Get the manifest of the dist
+	local info = manif.info(sys.path(dist, "dist.info"))
+	if not info then return nil, "Dist does not contain valid dist.info in " .. dist  end
+
+	-- Create temporary folder
+	local pkg = info.name .. "-" .. info.version .. "-" .. info.arch .. "-" .. info.type
+	if info.arch == "Universal" and info.type == "source" then
+		pkg = info.name .. "-" .. info.version
+	end
+
+	local tmp = sys.path(config.temp, pkg)
+	sys.makeDir(tmp)
+
+	-- Copy dist files into temporary folder
+	local files = info.files or sys.list(dist)
+	if not files then return nil, "Failed to collect files for dist in " .. dist end
+	
+	for i = 1, #files do
+		local file = files[i]
+		if sys.isDir(sys.path(depl, file)) then 
+			sys.makeDir(sys.path(tmp, file))
+		elseif file ~= "dist.info" then
+			local ok = sys.copy(sys.path(depl, file), sys.path(tmp, file))
+			if not ok then return nil, "Pack failed to copy file " .. file end
+		end
+	end
+	
+	-- Clean obsolete dist.info entries
+	info.path = nil
+	info.files = nil
+	local ok, err = persist.save(sys.path(tmp, "dist.info"), info)
+	if not ok then return nil, "Could not update dist.info." end
+		
+	-- Zip dist files in the temporary folder. The zip will be placed into LuaDist/tmp folder
+	-- This cleans up .git .svn and Mac .DS_Store files.
+	local ok = sys.zip(config.temp, pkg .. ".dist", pkg, '-x "*.git*" -x "*.svn*" -x "*~" -x "*.DS_Store*"')
+	if not ok then return nil, "Failed to compress files in" .. pkg end
+	local ok = sys.move(tmp .. ".dist", dir .. "/") -- Adding the "/" gets around ambiguity issues on Windows.
+	if not ok then return nil, "Could not move dist to target directory " .. dir end
+
+	-- Remove the temporary folder
+	if not config.debug then sys.delete(tmp) end
+	return true, "Sucessfully packed dist " .. dist .. " to " .. dir
+end
+
+--- Delete a deployed dist.
+-- @param dist string: dist to delete.
+-- @param depl string: deployment dir to delete from.
+-- @return ok, log: Returns success and nlog message.
+function delete(dist, depl)
+	assert(type(dist)=="string", "package.delete: Argument 'dist' is not a string.")
+	assert(type(dist)=="string", "package.delete: Argument 'depl' is not a string.")
+	
+	-- Get the manifest of the dist
+	local info = manif.info(sys.path(dist, "dist.info"))
+	if not info then return nil, "Dist does not contain valid dist.info in " .. dist  end
+
+	-- Delete installed files
+	local files = info.files
+	if not files then return nil, "Failed to collect files for dist in " .. dist end
+	
+	-- Remove list backwards to empty dirs 1st.
+	for i = #files, 1, -1 do
+		local file = sys.path(depl, files[i])
+		-- Delete deployed file
+		if sys.isFile(file) then
+			sys.delete(file)
+		end
+		-- Delete empty directories
+		if sys.isDir(file) then
+			local contents = sys.dir(file)
+			if #contents == 0 then
+				sys.delete(file)
+			end
+		end
+	end
+	
+	-- Delete dist directory
+	local ok = sys.delete(dist)
+	if not ok then return nil, "Deleting dist files failed in " .. dist end
+		
+	return true, "Successfully removed dist " .. dist
+end