rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/luarocks/validate.lua

@@ -0,0 +1,164 @@
+
+--- Sandboxed test of build/install of all packages in a repository (unfinished and disabled).
+module("luarocks.validate", package.seeall)
+
+local fs = require("luarocks.fs")
+local dir = require("luarocks.dir")
+local path = require("luarocks.path")
+local cfg = require("luarocks.cfg")
+local build = require("luarocks.build")
+local install = require("luarocks.install")
+local util = require("luarocks.util")
+
+help_summary = "Sandboxed test of build/install of all packages in a repository."
+
+help = [[
+<argument>, if given, is a local repository pathname.
+]]
+
+local function save_settings(repo)
+   local protocol, path = dir.split_url(repo)
+   table.insert(cfg.rocks_servers, 1, protocol.."://"..path)
+   return {
+      root_dir = cfg.root_dir,
+      rocks_dir = cfg.rocks_dir,
+      deploy_bin_dir = cfg.deploy_bin_dir,
+      deploy_lua_dir = cfg.deploy_lua_dir,
+      deploy_lib_dir = cfg.deploy_lib_dir,
+   }
+end
+
+local function restore_settings(settings)
+   cfg.root_dir = settings.root_dir
+   cfg.rocks_dir = settings.rocks_dir
+   cfg.deploy_bin_dir = settings.deploy_bin_dir
+   cfg.deploy_lua_dir = settings.deploy_lua_dir
+   cfg.deploy_lib_dir = settings.deploy_lib_dir
+   cfg.variables.ROCKS_TREE = settings.rocks_dir
+   cfg.variables.SCRIPTS_DIR = settings.deploy_bin_dir
+   table.remove(cfg.rocks_servers, 1)
+end
+
+local function prepare_sandbox(file)
+   local root_dir = fs.make_temp_dir(file):gsub("/+$", "")
+   cfg.root_dir = root_dir
+   cfg.rocks_dir = path.rocks_dir(root_dir)
+   cfg.deploy_bin_dir = path.deploy_bin_dir(root_dir)
+   cfg.variables.ROCKS_TREE = cfg.rocks_dir
+   cfg.variables.SCRIPTS_DIR = cfg.deploy_bin_dir
+   return root_dir
+end
+
+local function validate_rockspec(file)
+   local ok, err, errcode = build.build_rockspec(file, true)
+   if not ok then
+      util.printerr(err)
+   end
+   return ok, err, errcode
+end
+
+local function validate_src_rock(file)
+   local ok, err, errcode = build.build_rock(file, false)
+   if not ok then
+      util.printerr(err)
+   end
+   return ok, err, errcode
+end
+
+local function validate_rock(file)
+   local ok, err, errcode = install.install_binary_rock(file)
+   if not ok then
+      util.printerr(err)
+   end
+   return ok, err, errcode
+end
+
+local function validate(repo, flags)
+   local results = {
+      ok = {}
+   }
+   local settings = save_settings(repo)
+   local sandbox
+   if flags["quick"] then
+      sandbox = prepare_sandbox("luarocks_validate")
+   end
+   if not fs.exists(repo) then
+      return nil, repo.." is not a local repository."
+   end
+   for _, file in pairs(fs.list_dir(repo)) do for _=1,1 do
+      if file == "manifest" or file == "index.html" then
+         break -- continue for
+      end
+      local pathname = fs.absolute_name(dir.path(repo, file))
+      if not flags["quick"] then
+         sandbox = prepare_sandbox(file)
+      end
+      local ok, err, errcode
+      util.printout()
+      util.printout("Verifying "..pathname)
+      if file:match("%.rockspec$") then
+         ok, err, errcode = validate_rockspec(pathname)
+      elseif file:match("%.src%.rock$") then
+         ok, err, errcode = validate_src_rock(pathname)
+      elseif file:match("%.rock$") then
+         ok, err, errcode = validate_rock(pathname)
+      end
+      if ok then
+         table.insert(results.ok, {file=file} )
+      else
+         if not errcode then
+            errcode = "misc"
+         end
+         if not results[errcode] then
+            results[errcode] = {}
+         end
+         table.insert(results[errcode], {file=file, err=err} )
+      end
+      util.run_scheduled_functions()
+      if not flags["quick"] then
+         fs.delete(sandbox)
+      end
+      repeat until not fs.pop_dir()
+   end end
+   if flags["quick"] then
+      fs.delete(sandbox)
+   end
+   restore_settings(settings)
+   util.printout()
+   util.printout("Results:")
+   util.printout("--------")
+   util.printout("OK: "..tostring(#results.ok))
+   for _, entry in ipairs(results.ok) do
+      util.printout(entry.file)
+   end
+   for errcode, errors in pairs(results) do
+      if errcode ~= "ok" then
+         util.printout()
+         util.printout(errcode.." errors: "..tostring(#errors))
+         for _, entry in ipairs(errors) do
+            util.printout(entry.file, entry.err)
+         end
+      end
+   end
+
+   util.printout()
+   util.printout("Summary:")
+   util.printout("--------")
+   local total = 0
+   for errcode, errors in pairs(results) do
+      util.printout(errcode..": "..tostring(#errors))
+      total = total + #errors
+   end
+   util.printout("Total: "..total)
+   return true
+end
+
+function run(...)
+   local flags, repo = util.parse_flags(...)
+   repo = repo or cfg.rocks_dir
+
+   util.printout("Verifying contents of "..repo)
+
+   return validate(repo, flags)
+end
+

data/vendor/lua/lib/lua/luaunit.lua

@@ -0,0 +1,601 @@
+--[[ 
+        luaunit.lua
+
+Description: A unit testing framework
+Homepage: https://github.com/bluebird75/luaunit
+Initial author: Ryu, Gwang (http://www.gpgstudy.com/gpgiki/LuaUnit)
+Lot of improvements by Philippe Fremy <phil@freehackers.org>
+License: BSD License, see LICENSE.txt
+]]--
+
+argv = arg
+
+--[[ Some people like assertEquals( actual, expected ) and some people prefer 
+assertEquals( expected, actual ).
+]]--
+USE_EXPECTED_ACTUAL_IN_ASSERT_EQUALS = true
+
+DEFAULT_VERBOSITY = 1
+
+function assertError(f, ...)
+    -- assert that calling f with the arguments will raise an error
+    -- example: assertError( f, 1, 2 ) => f(1,2) should generate an error
+    local has_error, error_msg = not pcall( f, ... )
+    if has_error then return end 
+    error( "Expected an error but no error generated", 2 )
+end
+
+function mytostring( v )
+    if type(v) == 'string' then
+        return '"'..v..'"'
+    end
+    if type(v) == 'table' then
+        if v.__class__ then
+            return string.gsub( tostring(v), 'table', v.__class__ )
+        end
+        return tostring(v)
+    end
+    return tostring(v)
+end
+
+function assertEquals(actual, expected)
+    -- assert that two values are equal and calls error else
+    if  actual ~= expected  then
+
+        if not USE_EXPECTED_ACTUAL_IN_ASSERT_EQUALS then
+            expected, actual = actual, expected
+        end
+
+        local errorMsg
+        if type(expected) == 'string' then
+            errorMsg = "\nexpected: "..mytostring(expected).."\n"..
+                             "actual  : "..mytostring(actual).."\n"
+        else
+            errorMsg = "expected: "..mytostring(expected)..", actual: "..mytostring(actual)
+        end
+        error( errorMsg, 2 )
+    end
+end
+
+assert_equals = assertEquals
+assert_error = assertError
+
+function __genOrderedIndex( t )
+    local orderedIndex = {}
+    for key,_ in pairs(t) do
+        table.insert( orderedIndex, key )
+    end
+    table.sort( orderedIndex )
+    return orderedIndex
+end
+
+function orderedNext(t, state)
+    -- Equivalent of the next() function of table iteration, but returns the
+    -- keys in the alphabetic order. We use a temporary ordered key table that
+    -- is stored in the table being iterated.
+
+    --print("orderedNext: state = "..tostring(state) )
+    local key
+    if state == nil then
+        -- the first time, generate the index
+        t.__orderedIndex = nil
+        t.__orderedIndex = __genOrderedIndex( t )
+        key = t.__orderedIndex[1]
+        return key, t[key]
+    end
+    -- fetch the next value
+    key = nil
+    for i = 1,#t.__orderedIndex do
+        if t.__orderedIndex[i] == state then
+            key = t.__orderedIndex[i+1]
+        end
+    end
+
+    if key then
+        return key, t[key]
+    end
+
+    -- no more value to return, cleanup
+    t.__orderedIndex = nil
+    return
+end
+
+function orderedPairs(t)
+    -- Equivalent of the pairs() function on tables. Allows to iterate
+    -- in order
+    return orderedNext, t, nil
+end
+
+function strsplit(delimiter, text)
+-- Split text into a list consisting of the strings in text,
+-- separated by strings matching delimiter (which may be a pattern). 
+-- example: strsplit(",%s*", "Anna, Bob, Charlie,Dolores")
+    local list = {}
+    local pos = 1
+    if string.find("", delimiter, 1) then -- this would result in endless loops
+        error("delimiter matches empty string!")
+    end
+    while 1 do
+        local first, last = string.find(text, delimiter, pos)
+        if first then -- found?
+            table.insert(list, string.sub(text, pos, first-1))
+            pos = last+1
+        else
+            table.insert(list, string.sub(text, pos))
+            break
+        end
+    end
+    return list
+end
+
+
+function prefixString( prefix, s )
+    local t, s2
+    t = strsplit('\n', s)
+    s2 = prefix..table.concat(t, '\n'..prefix)
+    return s2
+end
+
+----------------------------------------------------------------
+--                     class TapOutput
+----------------------------------------------------------------
+
+TapOutput = { -- class
+    __class__ = 'TapOutput',
+    runner = nil,
+    result = nil,
+}
+TapOutput_MT = { __index = TapOutput }
+
+    function TapOutput:new()
+        local t = {}
+        t.verbosity = 0
+        setmetatable( t, TapOutput_MT )
+        return t
+    end
+    function TapOutput:startSuite() end
+    function TapOutput:startClass(className) end
+    function TapOutput:startTest(testName) end
+
+    function TapOutput:addFailure( errorMsg, stackTrace )
+       print(string.format("not ok %d\t%s", self.result.testCount, self.result.currentTestName ))
+       if self.verbosity > 0 then
+           print( prefixString( '    ', errorMsg ) )
+        end
+       if self.verbosity > 1 then
+           print( prefixString( '    ', stackTrace ) )
+        end
+    end
+
+    function TapOutput:endTest(testHasFailure)
+       if not self.result.currentTestHasFailure then
+          print(string.format("ok     %d\t%s", self.result.testCount, self.result.currentTestName ))
+       end
+    end
+
+    function TapOutput:endClass() end
+
+    function TapOutput:endSuite()
+       print("1.."..self.result.testCount)
+       return self.result.failureCount
+    end
+
+
+-- class TapOutput end
+
+
+----------------------------------------------------------------
+--                     class TextOutput
+----------------------------------------------------------------
+
+TextOutput = { __class__ = 'TextOutput' }
+TextOutput_MT = { -- class
+    __index = TextOutput
+}
+
+    function TextOutput:new()
+        local t = {}
+        t.runner = nil
+        t.result = nil
+        t.errorList ={}
+        t.verbosity = 1
+        setmetatable( t, TextOutput_MT )
+        return t
+    end
+
+    function TextOutput:startSuite()
+    end
+
+    function TextOutput:startClass(className)
+        if self.verbosity > 0 then
+            print( '>>>>>>>>> '.. self.result.currentClassName )
+        end
+    end
+
+    function TextOutput:startTest(testName)
+        if self.verbosity > 0 then
+            print( ">>> ".. self.result.currentTestName )
+        end
+    end
+
+    function TextOutput:addFailure( errorMsg, stackTrace )
+        table.insert( self.errorList, { self.result.currentTestName, errorMsg, stackTrace } )
+        if self.verbosity == 0 then
+            io.stdout:write("F")
+        end
+        if self.verbosity > 0 then
+            print( errorMsg )
+            print( 'Failed' )
+        end
+    end
+
+    function TextOutput:endTest(testHasFailure)
+        if not testHasFailure then
+            if self.verbosity > 0 then
+                --print ("Ok" )
+            else 
+                io.stdout:write(".")
+            end
+        end
+    end
+
+    function TextOutput:endClass()
+        if self.verbosity > 0 then
+           print()
+        end
+    end
+
+    function TextOutput:displayOneFailedTest( failure )
+        testName, errorMsg, stackTrace = unpack( failure )
+        print(">>> "..testName.." failed")
+        print( errorMsg )
+        if self.verbosity > 1 then
+            print( stackTrace )
+        end
+    end
+
+    function TextOutput:displayFailedTests()
+        if #self.errorList == 0 then return end
+        print("Failed tests:")
+        print("-------------")
+        for i,v in ipairs(self.errorList) do
+            self:displayOneFailedTest( v )
+        end
+        print()
+    end
+
+    function TextOutput:endSuite()
+        if self.verbosity == 0 then
+            print()
+        else
+            print("=========================================================")
+        end
+        self:displayFailedTests()
+        local successPercent, successCount
+        successCount = self.result.testCount - self.result.failureCount
+        if self.result.testCount == 0 then
+            successPercent = 100
+        else
+            successPercent = math.ceil( 100 * successCount / self.result.testCount )
+        end
+        print( string.format("Success : %d%% - %d / %d",
+            successPercent, successCount, self.result.testCount) )
+    end
+
+
+-- class TextOutput end
+
+
+----------------------------------------------------------------
+--                     class NilOutput
+----------------------------------------------------------------
+
+function nopCallable() 
+    --print(42) 
+    return nopCallable
+end
+
+NilOutput = {
+    __class__ = 'NilOuptut',    
+}
+NilOutput_MT = {
+    __index = nopCallable,
+}
+function NilOutput:new()
+    local t = {}
+    t.__class__ = 'NilOutput'
+    setmetatable( t, NilOutput_MT )
+    return t 
+end
+
+----------------------------------------------------------------
+--                     class LuaUnit
+----------------------------------------------------------------
+
+LuaUnit = {
+    outputType = TextOutput,
+    verbosity = DEFAULT_VERBOSITY,
+    __class__ = 'LuaUnit'
+}
+LuaUnit_MT = { __index = LuaUnit }
+
+    function LuaUnit:new()
+        local t = {}
+        setmetatable( t, LuaUnit_MT )
+        return t
+    end
+
+    -----------------[[ Utility methods ]]---------------------
+
+    function LuaUnit.isFunction(aObject) 
+        return 'function' == type(aObject)
+    end
+
+    --------------[[ Output methods ]]-------------------------
+
+    function LuaUnit:ensureSuiteStarted( )
+        if self.result and self.result.suiteStarted then
+            return
+        end
+        self:startSuite()
+    end
+
+    function LuaUnit:startSuite()
+        self.result = {}
+        self.result.failureCount = 0
+        self.result.testCount = 0
+        self.result.currentTestName = ""
+        self.result.currentClassName = ""
+        self.result.currentTestHasFailure = false
+        self.result.suiteStarted = true
+        self.outputType = self.outputType or TextOutput
+        self.output = self.outputType:new()
+        self.output.runner = self
+        self.output.result = self.result
+        self.output.verbosity = self.verbosity
+        self.output:startSuite()
+    end
+
+    function LuaUnit:startClass( className )
+        self.result.currentClassName = className
+        self.output:startClass( className )
+    end
+
+    function LuaUnit:startTest( testName  )
+        self.result.currentTestName = testName
+        self.result.testCount = self.result.testCount + 1
+        self.result.currentTestHasFailure = false
+        self.output:startTest( testName )
+    end
+
+    function LuaUnit:addFailure( errorMsg, stackTrace )
+        if not self.result.currentTestHasFailure then
+            self.result.failureCount = self.result.failureCount + 1
+            self.result.currentTestHasFailure = true
+        end
+        self.output:addFailure( errorMsg, stackTrace )
+    end
+
+    function LuaUnit:endTest()
+        self.output:endTest( self.result.currentTestHasFailure )
+        self.result.currentTestName = ""
+        self.result.currentTestHasFailure = false
+    end
+
+    function LuaUnit:endClass()
+        self.output:endClass()
+    end
+
+    function LuaUnit:endSuite()
+        self.result.suiteStarted = false
+        self.output:endSuite()
+    end
+
+    function LuaUnit:setOutputType(outputType)
+        -- default to text
+        -- tap produces results according to TAP format
+        if outputType:upper() == "NIL" then
+            self.outputType = NilOutput
+            return
+        end
+        if outputType:upper() == "TAP" then
+            self.outputType = TapOutput
+            return
+        end 
+        if outputType:upper() == "TEXT" then
+            self.outputType = TextOutput
+            return
+        end
+        error( 'No such format: '..outputType)
+    end
+
+    --------------[[ Runner ]]-----------------
+
+    SPLITTER = '\n>----------<\n'
+
+    function LuaUnit:protectedCall( classInstance , methodInstance)
+        -- if classInstance is nil, this is just a function run
+        local function err_handler(e)
+            return debug.traceback(e..SPLITTER, 4)
+        end
+
+        local ok=true, errorMsg, stackTrace
+        if classInstance then
+            -- stupid Lua < 5.2 does not allow xpcall with arguments so let's live with that
+            ok, errorMsg = xpcall( function () methodInstance(classInstance) end, err_handler )
+        else
+            ok, errorMsg = xpcall( function () methodInstance() end, err_handler )
+        end
+        if not ok then
+            t = strsplit( SPLITTER, errorMsg )
+            stackTrace = string.sub(t[2],2)
+            self:addFailure( t[1], stackTrace )
+        end
+
+        return ok
+    end
+
+
+    function LuaUnit:_runTestMethod(className, methodName, classInstance, methodInstance)
+        -- When executing a class method, all parameters are set
+        -- When executing a test function, className and classInstance are nil
+
+        if type(methodInstance) ~= 'function' then
+            error( tostring(methodName)..'must be a function, not '..type(methodInstance))
+        end
+
+        if className == nil then
+            className = '<TestFunction>'
+        end
+
+        if self.lastClassName ~= className then
+            if self.lastClassName ~= nil then
+                self:endClass()
+            end
+            self:startClass( className )
+            self.lastClassName = className
+        end
+
+        self:startTest(className..':'..methodName)
+
+        -- run setUp first(if any)
+        if classInstance and self.isFunction( classInstance.setUp ) then
+            self:protectedCall( classInstance, classInstance.setUp)
+        end
+
+        -- run testMethod()
+        if not self.result.currentTestHasFailure then
+            self:protectedCall( classInstance, methodInstance)
+        end
+
+        -- lastly, run tearDown(if any)
+        if classInstance and self.isFunction(classInstance.tearDown) then
+            self:protectedCall( classInstance, classInstance.tearDown)
+        end
+
+        self:endTest()
+    end
+
+    function LuaUnit:runSomeTest( someName, someInstance )
+        -- name is mandatory
+        -- if instance is not given, it's looked up in the global namespace
+        -- name can be a test class, a test function, or a test class + test method
+        -- instance can be a test class or a test function
+        -- example: runSomeTest( 'TestToto' )
+        -- example: runSomeTest( 'TestToto', TestToto )
+        -- example: runSomeTest( 'TestToto:testTiti' )
+        -- example: runSomeTest( 'TestToto:testTiti', TestToto )
+        -- example: runSomeTest( 'testFunction' )
+        -- example: runSomeTest( 'testFunction' , testFunction )
+
+        self:ensureSuiteStarted()
+
+        local hasMethod, methodName, methodInstance, className, classInstance
+        if someName == nil or someName == '' then
+            error( 'Name is required!')
+        end
+
+        hasMethod = string.find(someName, ':' )
+
+        -- name is class + method
+        if hasMethod then
+            methodName = string.sub(someName, hasMethod+1)
+            className = string.sub(someName,1,hasMethod-1)
+            classInstance = someInstance
+
+            classInstance = classInstance or _G[className]
+            if classInstance == nil then
+                error( "No such class: "..className )
+            end
+
+            if type(classInstance) ~= 'table' then
+                error( 'Instance must be a table')
+            end
+
+            methodInstance = classInstance[methodName]
+            if methodInstance == nil then
+                error( "Could not find method in class "..tostring(className).." for method "..tostring(methodName) )
+            end
+
+            self:_runTestMethod( className, methodName, classInstance, methodInstance )
+            return
+        end
+
+        if someInstance == nil then
+            someInstance = _G[someName]
+            if not someInstance then
+                error( "No such variable: "..someName )
+            end
+        end
+
+        if (type(someInstance) ~= 'table' and type(someInstance) ~= 'function') then
+            error( 'Instance must be function or table')
+        end
+
+        -- name is either a function or a class
+        if type(someInstance) == 'table' then
+            -- run all test methods of the class
+            className = someName
+            classInstance = someInstance
+
+            for methodName, methodInstance in orderedPairs(classInstance) do
+                if LuaUnit.isFunction(methodInstance) and string.sub(methodName, 1, 4) == "test" then
+                    self:_runTestMethod( className, methodName, classInstance, methodInstance )
+                end
+            end
+            return
+        end
+
+        if type(someInstance) == 'function' then
+            self:_runTestMethod( nil, someName, nil, someInstance )
+            return
+        end
+
+        error( 'Should never be reached...')
+
+    end
+
+    function LuaUnit:run(...)
+        -- Run some specific test classes.
+        -- If no arguments are passed, run the class names specified on the
+        -- command line. If no class name is specified on the command line
+        -- run all classes whose name starts with 'Test'
+        --
+        -- If arguments are passed, they must be strings of the class names 
+        -- that you want to run
+        local runner = self:new()
+        return runner:runSuite(...)
+    end
+
+    function LuaUnit:runSuite(...)
+        self:startSuite()
+
+        args={...};
+        if #args == 0 then
+            args = argv
+        end
+
+        if #args == 0 then
+            -- create the list if classes to run now ! If not, you can
+            -- not iterate over _G while modifying it.
+            args = {}
+            for key, val in pairs(_G) do 
+                if string.sub(key,1,4) == 'Test' then 
+                    table.insert( args, key )
+                end
+            end
+            table.sort( args )
+        end
+
+        for i,testName in ipairs( args ) do
+            self:runSomeTest( testName )
+        end
+
+        if self.lastClassName ~= nil then
+            self:endClass()
+        end
+        self:endSuite()
+        return self.result.failureCount
+    end
+-- class LuaUnit
+