code cleanups

lsyncd.lua

@@ -509,8 +509,8 @@ local Combiner = ( function( )
 	local function refi( d1, d2 )
 
 		-- but a directory blocks
-		if d2.path:byte( -1 ) == 47 then
+		if d2.path:byte( -1 ) == 47
-
+		then
 			log(
 				'Delay',
 				d2.etype,': ',d2.path,
@@ -519,7 +519,6 @@ local Combiner = ( function( )
 			)
 
 			return 'stack'
-
 		end
 
 		log(

tests/testlib.lua

@@ -5,36 +5,44 @@ posix = require('posix')
 local c1='\027[47;34m'
 local c0='\027[0m'
 
----
+--
 -- writes colorized
 --
 function cwriteln(...)
-	io.write(c1, ...)
+	io.write( c1, '++ ', ... )
 	io.write( c0, '\n' )
 end
 
------
+--
 -- initializes the pseudo random generator
 -- if environemnt 'SEED' is set, use that as seed.
 local seed = os.getenv( 'SEED')  or os.time( )
+
 math.randomseed( seed )
+
 cwriteln( 'random seed: ', seed )
 
------
+--
 -- creates a tmp directory
 --
 -- @returns the name of the directory
 --
 function mktempd( )
+
 	local f = io.popen( 'mktemp -td ltest.XXX', 'r' )
+
 	local s = f:read( '*a' )
+
 	f:close( )
+	
 	s = s:gsub( '[\n\r]+', ' ' )
+	
 	s = s:match( '^%s*(.-)%s*$' )
+	
 	return s
 end
 
------
+--
 -- creates a tmp directory with the
 -- typical lsyncd test architecture
 --
@@ -45,92 +53,127 @@ end
 
 function mktemps( )
 	local tdir = mktempd() .. '/'
+
 	cwriteln( 'using ', tdir, ' as test root' )
+
 	local srcdir = tdir..'src/'
+
 	local trgdir = tdir..'trg/'
+
 	posix.mkdir( srcdir )
+
 	posix.mkdir( trgdir )
+
 	return tdir, srcdir, trgdir
 end
 
-----
+--
--- Writes a file with 'text' in it.
+-- Writes a file with 'text' in it
 -- and adds a newline.
 --
 function writefile( filename, text )
+
 	local f = io.open( filename, 'w' )
-	if not f then
+
+	if not f
+	then
 		cwriteln( 'Cannot open "'..filename..'" for writing.' )
 		return false
 	end
+
 	f:write( text )
+
 	f:write( '\n' )
+
 	f:close( )
+
 	return true
 end
 
------
+--
 -- spawns a subprocess.
 --
 -- @returns the processes pid
 --
 function spawn(...)
+
 	args = { ... }
+
 	cwriteln( 'spawning: ', table.concat( args, ' ' ) )
+
 	local pid = posix.fork( )
-	if pid < 0 then
+
+	if pid < 0
+	then
 		cwriteln( 'Error, failed fork!' )
+
 		os.exit( -1 )
 	end
-	if pid == 0 then
+
+	if pid == 0
+	then
 		posix.exec( ... )
 		-- should not return
+
 		cwriteln( 'Error, failed to spawn: ', ... )
-		os.exit(-1);
+
+		os.exit( -1 )
 	end
+
 	return pid
 end
 
------
+--
 -- Makes a lot of random data
 --
 -- @param rootdir ... the directory to make data in
 -- @param n       ... roughly how much data action will done
 --
 function churn( rootdir, n )
+
 	-- all dirs created, indexed by integer and path
 	root = { name = '' }
+
 	alldirs = { root }
+
 	dirsWithFileI = { }
+
 	dirsWithFileD = { }
 
-	-----
+	--
 	-- returns the name of a directory
 	--
 	-- name is internal recursive paramter, keep it nil.
 	--
 	local function dirname( dir, name )
 		name = name or ''
-		if not dir then
+
+		if not dir
+		then
 			return name
 		end
+
 		return dirname( dir.parent, dir.name .. '/' .. name )
 	end
 
-	-----
+	--
 	-- Picks a random dir.
 	--
 	local function pickDir( notRoot )
-		if notRoot then
+		if notRoot
-			if #alldirs <= 2 then
+		then
+			if #alldirs <= 2
+			then
 				return nil
 			end
+
 			return alldirs[ math.random( 2, #alldirs ) ]
 		end
+
 		return alldirs[ math.random( #alldirs ) ]
 	end
 
-	----
+	--
 	-- Picks a random file.
 	--
 	-- Returns 3 values:
@@ -139,186 +182,264 @@ function churn(rootdir, n)
 	--  * number of files in directory
 	--
 	local function pickFile( )
+
 		-- picks the random directory
-		if #dirsWithFileI < 1 then
+		if #dirsWithFileI < 1
+		then
 			return
 		end
+
 		local rdir = dirsWithFileI[ math.random( 1, #dirsWithFileI ) ]
-		if not rdir then
+
+		if not rdir
+		then
 			return
 		end
 
 		-- counts the files in there
 		local c = 0
-		for name, _ in pairs(rdir) do
+
-			if #name == 2 then
+		for name, _ in pairs(rdir)
+		do
+			if #name == 2
+			then
 				c = c + 1
 			end
 		end
 
 		-- picks one file at random
 		local cr = math.random( 1, c )
+
 		local fn
-		for name, _ in pairs(rdir) do
+
-			if #name == 2 then
+		for name, _ in pairs( rdir )
+		do
+			if #name == 2
+			then
 				-- filenames are 2 chars wide.
 				cr = cr - 1
-				if cr == 0 then
+				if cr == 0
+				then
 					fn = name
 					break
 				end
 			end
 		end
+
 		return rdir, fn, c
 	end
 
-	-----
+	--
 	-- Removes a reference to a file
 	--
-	-- @param dir  --- directory reference
+	-- @param dir  -- directory reference
-	-- @param fn   --- filename
+	-- @param fn   -- filename
-	-- @param c    --- number of files in dir
+	-- @param c    -- number of files in dir
 	--
 	local function rmFileReference( dir, fn, c )
+
 		dir[fn] = nil
-		if c == 1 then
+
+		if c == 1
+		then
 			-- if last file from origin dir, it has no files anymore
-			for i, v in ipairs(dirsWithFileI) do
+			for i, v in ipairs( dirsWithFileI )
-				if v == dir then
+			do
+				if v == dir
+				then
 					table.remove( dirsWithFileI, i )
+
 					break
 				end
 			end
+
 			dirsWithFileD[ dir ] = nil
 		end
 	end
 
-	----
+	--
 	-- possible randomized behaviour.
 	-- just gives it a pause
 	--
 	local function sleep( )
 		cwriteln( '..zzz..' )
+
 		posix.sleep( 1 )
 	end
 
-	----
+	--
 	-- possible randomized behaviour.
 	-- creates a directory
 	--
 	local function mkdir( )
+
 		-- chooses a random directory to create it into
 		local rdir = pickDir( )
+
 		-- creates a new random one letter name
 		local nn = string.char( 96 + math.random( 26 ) )
-		if not rdir[nn] then
+
+		if not rdir[nn]
+		then
 			local ndir = {
 				name   = nn,
 				parent = rdir,
 			}
+
 			local dn = dirname( ndir )
+
 			rdir[ nn ] = dn
+
 			table.insert( alldirs, ndir )
+
 			cwriteln( 'mkdir  '..rootdir..dn )
+
 			posix.mkdir( rootdir..dn )
 		end
 	end
 
-	----
+	--
 	-- possible randomized behaviour.
 	-- Creates a file.
 	--
 	local function mkfile( )
+
 		-- chooses a random directory to create it into
 		local rdir = pickDir()
+
 		-- creates a new random one letter name
 		local nn = 'f'..string.char( 96 + math.random( 26 ) )
+
 		local fn = dirname( rdir ) .. nn
+
 		cwriteln( 'mkfile ' .. rootdir .. fn )
+
 		local f = io.open(rootdir..fn, 'w')
-		if f then
+
-			for i=1,10 do
+		if f
+		then
+			for i = 1, 10
+			do
 				f:write( string.char( 96 + math.random( 26 ) ) )
 			end
+
 			f:write( '\n' )
+
 			f:close( )
+
 			rdir[ nn ]=true
-			if not dirsWithFileD[rdir] then
+
+			if not dirsWithFileD[ rdir ]
+			then
 				table.insert( dirsWithFileI, rdir )
+
 				dirsWithFileD[ rdir ]=true
 			end
 		end
 	end
 
-	----
+	--
-	-- possible randomized behaviour,
+	-- Possible randomized behaviour:
-	-- moves a directory.
+	-- Moves a directory.
 	--
 	local function mvdir( )
-		if #alldirs <= 2 then
+
+		if #alldirs <= 2
+		then
 			return
 		end
+
 		-- chooses a random directory to move
 		local odir = pickDir( true )
+
 		-- chooses a random directory to move to
 		local tdir = pickDir( )
 
 		-- makes sure tdir is not a subdir of odir
 		local dd = tdir
-		while dd do
+
-			if odir == dd then
+		while dd
+		do
+			if odir == dd
+			then
 				return
 			end
+
 			dd = dd.parent
 		end
+
 		-- origin name in the target dir already
-		if tdir[odir.name] ~= nil then
+		if tdir[odir.name] ~= nil
+		then
 			return
 		end
+
 		local on = dirname( odir )
+
 		local tn = dirname( tdir )
+
 		cwriteln( 'mvdir  ', rootdir,on, ' -> ', rootdir, tn, odir.name )
+
 		os.rename( rootdir..on, rootdir..tn..odir.name )
+
 		odir.parent[ odir.name ] = nil
+
 		odir.parent = tdir
+
 		tdir[ odir.name ] = odir
 	end
 
-	----
+	--
 	-- possible randomized behaviour,
 	-- moves a file.
 	--
 	local function mvfile( )
 		local odir, fn, c = pickFile( )
-		if not odir then
+		
+		if not odir
+		then
 			return
 		end
+
 		-- picks a directory with a file at random
 		-- picks a target directory at random
 		local tdir = pickDir( )
+
 		local on = dirname( odir )
+
 		local tn = dirname( tdir )
+
 		cwriteln( 'mvfile ', rootdir, on, fn, ' -> ', rootdir, tn, fn )
+
 		os.rename( rootdir..on..fn, rootdir..tn..fn )
 		rmFileReference( odir, fn, c )
 
 		tdir[ fn ] = true
-		if not dirsWithFileD[tdir] then
+
+		if not dirsWithFileD[ tdir ]
+		then
 			dirsWithFileD[ tdir ] = true
+
 			table.insert( dirsWithFileI, tdir )
 		end
 	end
 
-	----
+	--
 	-- possible randomized behaviour,
 	-- removes a file.
 	--
 	local function rmfile( )
+
 		local dir, fn, c = pickFile( )
-		if dir then
+
+		if dir
+		then
 			local dn = dirname( dir )
+
 			cwriteln( 'rmfile ', rootdir, dn, fn )
+
 			posix.unlink( rootdir..dn..fn )
+
 			rmFileReference( dir, fn, c )
 		end
 	end
@@ -332,18 +453,26 @@ function churn(rootdir, n)
 	}
 
 	cwriteln( 'making random data' )
+
 	local ndice = 0
-	for i, d in ipairs(dice) do
+
+	for i, d in ipairs( dice )
+	do
 		ndice = ndice + d[ 1 ]
 		d[ 1 ] = ndice
 	end
 
-	for ai=1,n do
+	for ai = 1, n
+	do
 		-- throws a die what to do
 		local acn = math.random( ndice )
-		for i, d in ipairs(dice) do
+
-			if acn <= d[1] then
+		for i, d in ipairs( dice )
+		do
+			if acn <= d[ 1 ]
+			then
 				d[ 2 ]( )
+
 				break
 			end
 		end