rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/logging/console.lua

@@ -0,0 +1,22 @@
+-------------------------------------------------------------------------------
+-- Prints logging information to console
+--
+-- @author Thiago Costa Ponte (thiago@ideais.com.br)
+--
+-- @copyright 2004-2011 Kepler Project
+--
+-------------------------------------------------------------------------------
+
+require"logging"
+
+function logging.console(logPattern)
+
+    return logging.new(  function(self, level, message)
+                            io.stdout:write(logging.prepareLogMsg(logPattern, os.date(), level, message))
+                            return true
+                        end
+                      )
+end
+
+return logging.console
+

data/vendor/lua/lib/lua/logging/email.lua

@@ -0,0 +1,44 @@
+-------------------------------------------------------------------------------
+-- Emails logging information to the given recipient
+--
+-- @author Thiago Costa Ponte (thiago@ideais.com.br)
+--
+-- @copyright 2004-2011 Kepler Project
+--
+-------------------------------------------------------------------------------
+
+require"logging"
+local smtp = require"socket.smtp"
+
+function logging.email(params)
+
+    params = params or {}
+    params.headers = params.headers or {}
+    
+    if params.from == nil then
+        return nil, "'from' parameter is required"
+    end
+    if params.rcpt == nil then
+        return nil, "'rcpt' parameter is required"
+    end
+
+    return logging.new( function(self, level, message)
+                            local s = logging.prepareLogMsg(params.logPattern, os.date(), level, message)
+                            if params.headers.subject then
+                                params.headers.subject = logging.prepareLogMsg(params.headers.subject, os.date(), level, message)
+                            end
+                            local msg = { headers = params.headers, body = s }
+                            params.source = smtp.message(msg)
+                            
+                            local r, e = smtp.send(params)
+                            if not r then
+                                return nil, e
+                            end
+                            
+                            return true
+                        end
+                      )
+end
+
+return logging.email
+

data/vendor/lua/lib/lua/logging/file.lua

@@ -0,0 +1,55 @@
+-------------------------------------------------------------------------------
+-- Saves logging information in a file
+--
+-- @author Thiago Costa Ponte (thiago@ideais.com.br)
+--
+-- @copyright 2004-2011 Kepler Project
+--
+-------------------------------------------------------------------------------
+
+require"logging"
+
+local lastFileNameDatePattern
+local lastFileHandler
+
+local openFileLogger = function (filename, datePattern)
+	
+	local filename = string.format(filename, os.date(datePattern))
+	if (lastFileNameDatePattern ~= filename) then
+		
+		local f = io.open(filename, "a")
+		if (f) then
+			f:setvbuf ("line")
+			lastFileNameDatePattern = filename
+			lastFileHandler = f
+			return f
+		else
+			return nil, string.format("file `%s' could not be opened for writing", filename)	
+		end
+	else
+		return lastFileHandler		
+	end
+	
+end
+
+function logging.file(filename, datePattern, logPattern)
+
+    if type(filename) ~= "string" then
+        filename = "lualogging.log"
+    end
+
+    return logging.new( function(self, level, message)
+                            
+                            local f, msg = openFileLogger(filename, datePattern)
+                            if not f then
+						       return nil, msg
+						    end              
+                            local s = logging.prepareLogMsg(logPattern, os.date(), level, message)
+                            f:write(s)
+                            return true
+                        end
+                      )
+end
+
+return logging.file
+

data/vendor/lua/lib/lua/logging/rolling_file.lua

@@ -0,0 +1,81 @@
+---------------------------------------------------------------------------
+-- RollingFileAppender is a FileAppender that rolls over the logfile 
+-- once it has reached a certain size limit. It also mantains a 
+-- maximum number of log files.
+--
+-- @author Tiago Cesar Katcipis (tiagokatcipis@gmail.com)
+--
+-- @copyright 2004-2007 Kepler Project
+---------------------------------------------------------------------------
+
+require"logging"
+
+
+local function openFile(self)
+    self.file = io.open(self.filename, "a")
+    if not self.file then
+        return nil, string.format("file `%s' could not be opened for writing", self.filename)
+    end
+    self.file:setvbuf ("line")
+    return self.file
+end
+
+local rollOver = function (self)
+
+    for i = self.maxIndex - 1, 1, -1 do
+        -- files may not exist yet, lets ignore the possible errors.
+        os.rename(self.filename.."."..i, self.filename.."."..i+1)
+    end
+
+    self.file:close()
+    self.file = nil
+
+    local _, msg = os.rename(self.filename, self.filename..".".."1")
+
+    if msg then 
+        return nil, string.format("error %s on log rollover", msg)
+    end
+
+    return openFile(self)    
+end
+
+
+local openRollingFileLogger = function (self)
+	
+    if not self.file then
+        return openFile(self) 
+    end
+
+    local filesize = self.file:seek("end", 0)
+ 
+    if (filesize < self.maxSize) then 
+        return self.file
+    end
+
+    return rollOver(self)
+end
+
+
+function logging.rolling_file(filename, maxFileSize, maxBackupIndex, logPattern)
+
+    if type(filename) ~= "string" then
+        filename = "lualogging.log"
+    end
+
+    local obj = {  filename     = filename, 
+                   maxSize      = maxFileSize,
+                   maxIndex     = maxBackupIndex or 1
+                }
+
+    return logging.new( function(self, level, message)
+                            
+                            local f, msg = openRollingFileLogger(obj)
+                            if not f then
+			        return nil, msg
+		            end              
+                            local s = logging.prepareLogMsg(logPattern, os.date(), level, message)
+                            f:write(s)
+                            return true
+                        end
+                      )
+end

data/vendor/lua/lib/lua/logging/socket.lua

@@ -0,0 +1,35 @@
+-------------------------------------------------------------------------------
+-- Sends the logging information through a socket using luasocket
+--
+-- @author Thiago Costa Ponte (thiago@ideais.com.br)
+--
+-- @copyright 2004-2011 Kepler Project
+--
+-------------------------------------------------------------------------------
+
+require"logging"
+local socket = require"socket"
+
+function logging.socket(address, port, logPattern)
+
+    return logging.new( function(self, level, message)
+                            local s = logging.prepareLogMsg(logPattern, os.date(), level, message)
+
+                            local socket, err = socket.connect(address, port)
+                            if not socket then
+                                return nil, err
+                            end
+                            
+                            local cond, err = socket:send(s)
+                            if not cond then
+                                return nil, err
+                            end
+                            socket:close()
+                            
+                            return true
+                        end
+                      )
+end
+
+return logging.socket
+

data/vendor/lua/lib/lua/logging/sql.lua

@@ -0,0 +1,64 @@
+-------------------------------------------------------------------------------
+-- Saves the logging information in a table using luasql
+--
+-- @author Thiago Costa Ponte (thiago@ideais.com.br)
+--
+-- @copyright 2004-2011 Kepler Project
+--
+-------------------------------------------------------------------------------
+
+require"logging"
+
+function logging.sql(params)
+
+	params = params or {}
+    params.tablename = params.tablename or "LogTable"
+    params.logdatefield = params.logdatefield or "LogDate"
+    params.loglevelfield = params.loglevelfield or "LogLevel"
+    params.logmessagefield = params.logmessagefield or "LogMessage"
+
+	if params.connectionfactory == nil or type(params.connectionfactory) ~= "function" then
+		return nil, "No specified connection factory function"
+	end
+	
+    local con, err
+    if params.keepalive then
+        con, err = params.connectionfactory()
+    end
+    
+    return logging.new( function(self, level, message)
+                            if (not params.keepalive) or (con == nil) then
+                                con, err = params.connectionfactory()
+                                if not con then
+                                    return nil, err
+                                end
+                            end
+                            
+                            local logDate = os.date("%Y-%m-%d %H:%M:%S")
+                            local insert  = string.format("INSERT INTO %s (%s, %s, %s) VALUES ('%s', '%s', '%s')",
+                                                          params.tablename, params.logdatefield, params.loglevelfield, 
+                                                          params.logmessagefield, logDate, level, string.gsub(message, "'", "''"))
+                            
+                            local ret, err = pcall(con.execute, con, insert)
+                            if not ret then
+                                con, err = params.connectionfactory()
+                                if not con then
+                                    return nil, err
+                                end
+                                ret, err = con:execute(insert)
+                                if not ret then
+                                    return nil, err
+                                end
+                            end
+                            
+                            if not params.keepalive then
+                                con:close()
+                            end
+                            
+                            return true
+                        end
+                      )
+end
+
+return logging.sql
+

data/vendor/lua/lib/lua/loop/base.lua

@@ -0,0 +1,68 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP - Lua Object-Oriented Programming                            --
+-- Release: 2.3 beta                                                          --
+-- Title  : Base Class Model                                                  --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Exported API:                                                              --
+--   class(class)                                                             --
+--   new(class, ...)                                                          --
+--   classof(object)                                                          --
+--   isclass(class)                                                           --
+--   instanceof(object, class)                                                --
+--   memberof(class, name)                                                    --
+--   members(class)                                                           --
+--------------------------------------------------------------------------------
+
+local pairs        = pairs
+local unpack       = unpack
+local rawget       = rawget
+local setmetatable = setmetatable
+local getmetatable = getmetatable
+
+module "loop.base"
+
+--------------------------------------------------------------------------------
+function rawnew(class, object)
+	return setmetatable(object or {}, class)
+end
+--------------------------------------------------------------------------------
+function new(class, ...)
+	if class.__init
+		then return class:__init(...)
+		else return rawnew(class, ...)
+	end
+end
+--------------------------------------------------------------------------------
+function initclass(class)
+	if class == nil then class = {} end
+	if class.__index == nil then class.__index = class end
+	return class
+end
+--------------------------------------------------------------------------------
+local MetaClass = { __call = new }
+function class(class)
+	return setmetatable(initclass(class), MetaClass)
+end
+--------------------------------------------------------------------------------
+classof = getmetatable
+--------------------------------------------------------------------------------
+function isclass(class)
+	return classof(class) == MetaClass
+end
+--------------------------------------------------------------------------------
+function instanceof(object, class)
+	return classof(object) == class
+end
+--------------------------------------------------------------------------------
+memberof = rawget
+--------------------------------------------------------------------------------
+members = pairs

data/vendor/lua/lib/lua/loop/cached.lua

@@ -0,0 +1,312 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP - Lua Object-Oriented Programming                            --
+-- Release: 2.3 beta                                                          --
+-- Title  : Cached Class Model                                                --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Exported API:                                                              --
+--   class(class, ...)                                                        --
+--   new(class, ...)                                                          --
+--   classof(object)                                                          --
+--   isclass(class)                                                           --
+--   instanceof(object, class)                                                --
+--   memberof(class, name)                                                    --
+--   members(class)                                                           --
+--   superclass(class)                                                        --
+--   subclassof(class, super)                                                 --
+--   supers(class)                                                            --
+--   allmembers(class)                                                        --
+--------------------------------------------------------------------------------
+
+local type         = type
+local unpack       = unpack
+local pairs        = pairs
+local rawget       = rawget
+local rawset       = rawset
+local require      = require
+local ipairs       = ipairs
+local setmetatable = setmetatable
+local select       = select
+
+local table = require "loop.table"
+
+module "loop.cached"
+--------------------------------------------------------------------------------
+local OrderedSet  = require "loop.collection.OrderedSet"
+local base        = require "loop.multiple"
+--------------------------------------------------------------------------------
+table.copy(base, _M)
+--------------------------------------------------------------------------------
+local function subsiterator(queue, class)
+	class = queue[class]
+	if class then
+		for sub in pairs(class.subs) do
+			queue:enqueue(sub)
+		end
+		return class
+	end
+end
+function subs(class)
+	queue = OrderedSet()
+	queue:enqueue(class)
+	return subsiterator, queue, OrderedSet.firstkey
+end
+--------------------------------------------------------------------------------
+local function proxy_newindex(proxy, field, value)
+	return base.classof(proxy):updatefield(field, value)
+end
+--------------------------------------------------------------------------------
+function getclass(class)
+	local cached = base.classof(class)
+	if base.instanceof(cached, CachedClass) then
+		return cached
+	end
+end
+--------------------------------------------------------------------------------
+local ClassMap = base.new { __mode = "k" }
+--------------------------------------------------------------------------------
+CachedClass = base.class()
+
+function CachedClass:__init(class)
+	local meta = {}
+	self = base.rawnew(self, {
+		__call = new,
+		__index = meta,
+		__newindex = proxy_newindex,
+		supers = {},
+		subs = {},
+		members = table.copy(class, {}),
+		class = meta,
+	})
+	self.proxy = setmetatable(class and table.clear(class) or {}, self)
+	ClassMap[self.class] = self.proxy
+	return self
+end
+
+function CachedClass:updatehierarchy(...)
+	-- separate cached from non-cached classes
+	local caches = {}
+	local supers = {}
+	for i = 1, select("#", ...) do
+		local super = select(i, ...)
+		local cached = getclass(super)
+		if cached
+			then caches[#caches + 1] = cached
+			else supers[#supers + 1] = super
+		end
+	end
+
+	-- remove it from its old superclasses
+	for _, super in ipairs(self.supers) do
+		super:removesubclass(self)
+	end
+	
+	-- update superclasses
+	self.uncached = supers
+	self.supers = caches
+
+	-- register as subclass in all superclasses
+	for _, super in ipairs(self.supers) do
+		super:addsubclass(self)
+	end
+end
+
+function CachedClass:updateinheritance()
+	-- relink all affected classes
+	for sub in subs(self) do
+		sub:updatemembers()
+		sub:updatesuperclasses()
+	end
+end
+
+function CachedClass:addsubclass(class)
+	self.subs[class] = true
+end
+
+function CachedClass:removesubclass(class)
+	self.subs[class] = nil
+end
+
+function CachedClass:updatesuperclasses()
+	local uncached = {}
+	-- copy uncached superclasses defined in the class
+	for _, super in ipairs(self.uncached) do
+		if not uncached[super] then
+			uncached[super] = true
+			uncached[#uncached + 1] = super
+		end
+	end
+	-- copy inherited uncached superclasses
+	for _, cached in ipairs(self.supers) do
+		for _, super in base.supers(cached.class) do
+			if not uncached[super] then
+				uncached[super] = true
+				uncached[#uncached + 1] = super
+			end
+		end
+	end
+	base.class(self.class, unpack(uncached))
+end
+
+function CachedClass:updatemembers()
+	local class = table.clear(self.class)
+	for i = #self.supers, 1, -1 do
+		local super = self.supers[i].class
+		-- copy inherited members
+		table.copy(super, class)
+		-- do not copy the default __index value
+		if rawget(class, "__index") == super then
+			rawset(class, "__index", nil)
+		end
+	end
+	-- copy members defined in the class
+	table.copy(self.members, class)
+	-- set the default __index value
+	if rawget(class, "__index") == nil then
+		rawset(class, "__index", class)
+	end
+end
+
+function CachedClass:updatefield(name, member)
+	-- update member list
+	local members = self.members
+	members[name] = member
+
+	-- get old linkage
+	local class = self.class
+	local old = class[name]
+	
+	-- replace old linkage for the new one
+	class[name] = member
+	local queue = OrderedSet()
+	for sub in pairs(self.subs) do
+		queue:enqueue(sub)
+	end
+	while queue:head() do
+		local current = queue:dequeue()
+		class = current.class
+		members = current.members
+		if members[name] == nil then
+			for _, super in ipairs(current.supers) do
+				local superclass = super.class
+				if superclass[name] ~= nil then
+					if superclass[name] ~= class[name] then
+						class[name] = superclass[name]
+						for sub in pairs(current.subs) do
+							queue:enqueue(sub)
+						end
+					end
+					break
+				end
+			end
+		end
+	end
+	return old
+end
+--------------------------------------------------------------------------------
+function class(class, ...)
+	class = getclass(class) or CachedClass(class)
+	class:updatehierarchy(...)
+	class:updateinheritance()
+	return class.proxy
+end
+--------------------------------------------------------------------------------
+function rawnew(class, object)
+	local cached = getclass(class)
+	if cached then class = cached.class end
+	return base.rawnew(class, object)
+end
+--------------------------------------------------------------------------------
+function new(class, ...)
+	if class.__init
+		then return class:__init(...)
+		else return rawnew(class, ...)
+	end
+end
+--------------------------------------------------------------------------------
+function classof(object)
+	local class = base.classof(object)
+	return ClassMap[class] or class
+end
+--------------------------------------------------------------------------------
+function isclass(class)
+	return getclass(class) ~= nil
+end
+--------------------------------------------------------------------------------
+function superclass(class)
+	local supers = {}
+	local cached = getclass(class)
+	if cached then
+		for index, super in ipairs(cached.supers) do
+			supers[index] = super.proxy
+		end
+		class = cached.class
+	end
+	for _, super in base.supers(class) do
+		supers[#supers + 1] = super
+	end
+	return unpack(supers)
+end
+--------------------------------------------------------------------------------
+local function icached(cached, index)
+	local super
+	local supers = cached.supers
+	index = index + 1
+	-- check if index points to a cached superclass
+	super = supers[index]
+	if super then return index, super.proxy end
+	-- check if index points to an uncached superclass
+	super = cached.uncached[index - #supers]
+	if super then return index, super end
+end
+function supers(class)
+	local cached = getclass(class)
+	if cached
+		then return icached, cached, 0
+		else return base.supers(class)
+	end
+end
+--------------------------------------------------------------------------------
+function subclassof(class, super)
+	if class == super then return true end
+	for _, superclass in supers(class) do
+		if subclassof(superclass, super) then return true end
+	end
+	return false
+end
+--------------------------------------------------------------------------------
+function instanceof(object, class)
+	return subclassof(classof(object), class)
+end
+--------------------------------------------------------------------------------
+function memberof(class, name)
+	local cached = getclass(class)
+	if cached
+		then return cached.members[name]
+		else return base.member(class, name)
+	end
+end
+--------------------------------------------------------------------------------
+function members(class)
+	local cached = getclass(class)
+	if cached
+		then return pairs(cached.members)
+		else return base.members(class)
+	end
+end
+--------------------------------------------------------------------------------
+function allmembers(class)
+	local cached = getclass(class)
+	if cached
+		then return pairs(cached.class)
+		else return base.members(class)
+	end
+end