rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/pl/file.lua

@@ -0,0 +1,70 @@
+--- File manipulation functions: reading, writing, moving and copying.
+--
+-- Dependencies: `pl.utils`, `pl.dir`, `pl.path`
+-- @module pl.file
+local os = os
+local utils = require 'pl.utils'
+local dir = require 'pl.dir'
+local path = require 'pl.path'
+
+--[[
+module ('pl.file',utils._module)
+]]
+local file = {}
+
+--- return the contents of a file as a string
+-- @class function
+-- @name file.read
+-- @param filename The file path
+-- @return file contents
+file.read = utils.readfile
+
+--- write a string to a file
+-- @class function
+-- @name file.write
+-- @param filename The file path
+-- @param str The string
+file.write = utils.writefile
+
+--- copy a file.
+-- @class function
+-- @name file.copy
+-- @param src source file
+-- @param dest destination file
+-- @param flag true if you want to force the copy (default)
+-- @return true if operation succeeded
+file.copy = dir.copyfile
+
+--- move a file.
+-- @class function
+-- @name file.move
+-- @param src source file
+-- @param dest destination file
+-- @return true if operation succeeded, else false and the reason for the error.
+file.move = dir.movefile
+
+--- Return the time of last access as the number of seconds since the epoch.
+-- @class function
+-- @name file.access_time
+-- @param path A file path
+file.access_time = path.getatime
+
+---Return when the file was created.
+-- @class function
+-- @name file.creation_time
+-- @param path A file path
+file.creation_time = path.getctime
+
+--- Return the time of last modification
+-- @class function
+-- @name file.modified_time
+-- @param path A file path
+file.modified_time = path.getmtime
+
+--- Delete a file
+-- @class function
+-- @name file.delete
+-- @param path A file path
+file.delete = os.remove
+
+return file

data/vendor/lua/lib/lua/pl/func.lua

@@ -0,0 +1,376 @@
+--- Functional helpers like composition, binding and placeholder expressions.
+-- Placeholder expressions are useful for short anonymous functions, and were
+-- inspired by the Boost Lambda library.
+--
+--    > utils.import 'pl.func'
+--    > ls = List{10,20,30}
+--    > = ls:map(_1+1)
+--    {11,21,31}
+--
+-- They can also be used to _bind_ particular arguments of a function.
+--
+--    > p = bind(print,'start>',_0)
+--    > p(10,20,30)
+--    > start>   10   20  30
+--
+-- See @{07-functional.md.Creating_Functions_from_Functions|the Guide}
+--
+-- Dependencies: `pl.utils`, `pl.tablex`
+-- @module pl.func
+local type,select,setmetatable,getmetatable,rawset = type,select,setmetatable,getmetatable,rawset
+local concat,append = table.concat,table.insert
+local max = math.max
+local print,tostring = print,tostring
+local pairs,ipairs,loadstring,rawget,unpack  = pairs,ipairs,loadstring,rawget,unpack
+local _G = _G
+local utils = require 'pl.utils'
+local tablex = require 'pl.tablex'
+local map = tablex.map
+local _DEBUG = rawget(_G,'_DEBUG')
+local assert_arg = utils.assert_arg
+
+local func = {}
+
+-- metatable for Placeholder Expressions (PE)
+local _PEMT = {}
+
+local function P (t)
+    setmetatable(t,_PEMT)
+    return t
+end
+
+func.PE = P
+
+local function isPE (obj)
+    return getmetatable(obj) == _PEMT
+end
+
+func.isPE = isPE
+
+-- construct a placeholder variable (e.g _1 and _2)
+local function PH (idx)
+    return P {op='X',repr='_'..idx, index=idx}
+end
+
+-- construct a constant placeholder variable (e.g _C1 and _C2)
+local function CPH (idx)
+    return P {op='X',repr='_C'..idx, index=idx}
+end
+
+func._1,func._2,func._3,func._4,func._5 = PH(1),PH(2),PH(3),PH(4),PH(5)
+func._0 = P{op='X',repr='...',index=0}
+
+function func.Var (name)
+    local ls = utils.split(name,'[%s,]+')
+    local res = {}
+    for _,n in ipairs(ls) do
+        append(res,P{op='X',repr=n,index=0})
+    end
+    return unpack(res)
+end
+
+function func._ (value)
+    return P{op='X',repr=value,index='wrap'}
+end
+
+local repr
+
+func.Nil = func.Var 'nil'
+
+function _PEMT.__index(obj,key)
+    return P{op='[]',obj,key}
+end
+
+function _PEMT.__call(fun,...)
+    return P{op='()',fun,...}
+end
+
+function _PEMT.__tostring (e)
+    return repr(e)
+end
+
+function _PEMT.__unm(arg)
+    return P{op='-',arg}
+end
+
+function func.Not (arg)
+    return P{op='not',arg}
+end
+
+function func.Len (arg)
+    return P{op='#',arg}
+end
+
+
+local function binreg(context,t)
+    for name,op in pairs(t) do
+        rawset(context,name,function(x,y)
+            return P{op=op,x,y}
+        end)
+    end
+end
+
+local function import_name (name,fun,context)
+    rawset(context,name,function(...)
+        return P{op='()',fun,...}
+    end)
+end
+
+local imported_functions = {}
+
+local function is_global_table (n)
+    return type(_G[n]) == 'table'
+end
+
+--- wrap a table of functions. This makes them available for use in
+-- placeholder expressions.
+-- @param tname a table name
+-- @param context context to put results, defaults to environment of caller
+function func.import(tname,context)
+    assert_arg(1,tname,'string',is_global_table,'arg# 1: not a name of a global table')
+    local t = _G[tname]
+    context = context or _G
+    for name,fun in pairs(t) do
+        import_name(name,fun,context)
+        imported_functions[fun] = name
+    end
+end
+
+--- register a function for use in placeholder expressions.
+-- @param fun a function
+-- @param name an optional name
+-- @return a placeholder functiond
+function func.register (fun,name)
+    assert_arg(1,fun,'function')
+    if name then
+        assert_arg(2,name,'string')
+        imported_functions[fun] = name
+    end
+    return function(...)
+        return P{op='()',fun,...}
+    end
+end
+
+function func.lookup_imported_name (fun)
+    return imported_functions[fun]
+end
+
+local function _arg(...) return ... end
+
+function func.Args (...)
+    return P{op='()',_arg,...}
+end
+
+-- binary and unary operators, with their precedences (see 2.5.6)
+local operators = {
+    ['or'] = 0,
+    ['and'] = 1,
+    ['=='] = 2, ['~='] = 2, ['<'] = 2, ['>'] = 2,  ['<='] = 2,   ['>='] = 2,
+    ['..'] = 3,
+    ['+'] = 4, ['-'] = 4,
+    ['*'] = 5, ['/'] = 5, ['%'] = 5,
+    ['not'] = 6, ['#'] = 6, ['-'] = 6,
+    ['^'] = 7
+}
+
+-- comparisons (as prefix functions)
+binreg (func,{And='and',Or='or',Eq='==',Lt='<',Gt='>',Le='<=',Ge='>='})
+
+-- standard binary operators (as metamethods)
+binreg (_PEMT,{__add='+',__sub='-',__mul='*',__div='/',__mod='%',__pow='^',__concat='..'})
+
+binreg (_PEMT,{__eq='=='})
+
+--- all elements of a table except the first.
+-- @param ls a list-like table.
+function func.tail (ls)
+    assert_arg(1,ls,'table')
+    local res = {}
+    for i = 2,#ls do
+        append(res,ls[i])
+    end
+    return res
+end
+
+--- create a string representation of a placeholder expression.
+-- @param e a placeholder expression
+-- @param lastpred not used
+function repr (e,lastpred)
+    local tail = func.tail
+    if isPE(e) then
+        local pred = operators[e.op]
+        local ls = map(repr,e,pred)
+        if pred then --unary or binary operator
+            if #ls ~= 1 then
+                local s = concat(ls,' '..e.op..' ')
+                if lastpred and lastpred > pred then
+                    s = '('..s..')'
+                end
+                return s
+            else
+                return e.op..' '..ls[1]
+            end
+        else -- either postfix, or a placeholder
+            if e.op == '[]' then
+                return ls[1]..'['..ls[2]..']'
+            elseif e.op == '()' then
+                local fn
+                if ls[1] ~= nil then -- was _args, undeclared!
+                    fn = ls[1]
+                else
+                    fn = ''
+                end
+                return fn..'('..concat(tail(ls),',')..')'
+            else
+                return e.repr
+            end
+        end
+    elseif type(e) == 'string' then
+        return '"'..e..'"'
+    elseif type(e) == 'function' then
+        local name = func.lookup_imported_name(e)
+        if name then return name else return tostring(e) end
+    else
+        return tostring(e) --should not really get here!
+    end
+end
+func.repr = repr
+
+-- collect all the non-PE values in this PE into vlist, and replace each occurence
+-- with a constant PH (_C1, etc). Return the maximum placeholder index found.
+local collect_values
+function collect_values (e,vlist)
+    if isPE(e) then
+        if e.op ~= 'X' then
+            local m = 0
+            for i,subx in ipairs(e) do
+                local pe = isPE(subx)
+                if pe then
+                    if subx.op == 'X' and subx.index == 'wrap' then
+                        subx = subx.repr
+                        pe = false
+                    else
+                        m = max(m,collect_values(subx,vlist))
+                    end
+                end
+                if not pe then
+                    append(vlist,subx)
+                    e[i] = CPH(#vlist)
+                end
+            end
+            return m
+        else -- was a placeholder, it has an index...
+            return e.index
+        end
+    else -- plain value has no placeholder dependence
+        return 0
+    end
+end
+func.collect_values = collect_values
+
+--- instantiate a PE into an actual function. First we find the largest placeholder used,
+-- e.g. _2; from this a list of the formal parameters can be build. Then we collect and replace
+-- any non-PE values from the PE, and build up a constant binding list.
+-- Finally, the expression can be compiled, and e.__PE_function is set.
+-- @param e a placeholder expression
+-- @return a function
+function func.instantiate (e)
+    local consts,values,parms = {},{},{}
+    local rep, err, fun
+    local n = func.collect_values(e,values)
+    for i = 1,#values do
+        append(consts,'_C'..i)
+        if _DEBUG then print(i,values[i]) end
+    end
+    for i =1,n do
+        append(parms,'_'..i)
+    end
+    consts = concat(consts,',')
+    parms = concat(parms,',')
+    rep = repr(e)
+    local fstr = ('return function(%s) return function(%s) return %s end end'):format(consts,parms,rep)
+    if _DEBUG then print(fstr) end
+    fun,err = loadstring(fstr,'fun')
+    if not fun then return nil,err end
+    fun = fun()  -- get wrapper
+    fun = fun(unpack(values)) -- call wrapper (values could be empty)
+    e.__PE_function = fun
+    return fun
+end
+
+--- instantiate a PE unless it has already been done.
+-- @param e a placeholder expression
+-- @return the function
+function func.I(e)
+    if rawget(e,'__PE_function')  then
+        return e.__PE_function
+    else return func.instantiate(e)
+    end
+end
+
+utils.add_function_factory(_PEMT,func.I)
+
+--- bind the first parameter of the function to a value.
+-- @class function
+-- @name func.curry
+-- @param fn a function of one or more arguments
+-- @param p a value
+-- @return a function of one less argument
+-- @usage (curry(math.max,10))(20) == math.max(10,20)
+func.curry = utils.bind1
+
+--- create a function which chains two functions.
+-- @param f a function of at least one argument
+-- @param g a function of at least one argument
+-- @return a function
+-- @usage printf = compose(io.write,string.format)
+function func.compose (f,g)
+    return function(...) return f(g(...)) end
+end
+
+--- bind the arguments of a function to given values.
+-- bind(fn,v,_2) is equivalent to curry(fn,v).
+-- @param fn a function of at least one argument
+-- @param ... values or placeholder variables
+-- @return a function
+-- @usage (bind(f,_1,a))(b) == f(a,b)
+-- @usage (bind(f,_2,_1))(a,b) == f(b,a)
+function func.bind(fn,...)
+    local args = table.pack(...)
+    local holders,parms,bvalues,values = {},{},{'fn'},{}
+    local nv,maxplace,varargs = 1,0,false
+    for i = 1,args.n do
+        local a = args[i]
+        if isPE(a) and a.op == 'X' then
+            append(holders,a.repr)
+            maxplace = max(maxplace,a.index)
+            if a.index == 0 then varargs = true end
+        else
+            local v = '_v'..nv
+            append(bvalues,v)
+            append(holders,v)
+            append(values,a)
+            nv = nv + 1
+        end
+    end
+    for np = 1,maxplace do
+        append(parms,'_'..np)
+    end
+    if varargs then append(parms,'...') end
+    bvalues = concat(bvalues,',')
+    parms = concat(parms,',')
+    holders = concat(holders,',')
+    local fstr = ([[
+return function (%s)
+    return function(%s) return fn(%s) end
+end
+]]):format(bvalues,parms,holders)
+    if _DEBUG then print(fstr) end
+    local res,err = loadstring(fstr)
+    res = res()
+    return res(fn,unpack(values))
+end
+
+return func
+
+

data/vendor/lua/lib/lua/pl/init.lua

@@ -0,0 +1,68 @@
+--------------
+-- Entry point for loading all PL libraries only on demand.
+-- Requiring 'pl' means that whenever a module is implicitly accesssed
+-- (e.g. `utils.split`)
+-- then that module is dynamically loaded. The submodules are all brought into
+-- the global space.
+-- @module pl
+
+local modules = {
+    utils = true,path=true,dir=true,tablex=true,stringio=true,sip=true,
+    input=true,seq=true,lexer=true,stringx=true,
+    config=true,pretty=true,data=true,func=true,text=true,
+    operator=true,lapp=true,array2d=true,
+    comprehension=true,xml=true,
+    test = true, app = true, file = true, class = true, List = true,
+    Map = true, Set = true, OrderedMap = true, MultiMap = true,
+    Date = true,
+    -- classes --
+}
+_G.utils = require 'pl.utils'
+
+for name,klass in pairs(_G.utils.stdmt) do
+    klass.__index = function(t,key)
+        return require ('pl.'..name)[key]
+    end;
+end
+
+-- ensure that we play nice with libraries that also attach a metatable
+-- to the global table; always forward to a custom __index if we don't
+-- match
+
+local _hook,_prev_index
+local gmt = {}
+local prev_gmt = getmetatable(_G)
+if prev_gmt then
+    _prev_index = prev_gmt.__index
+    if prev_gmt.__newindex then
+        gmt.__index = prev_gmt.__newindex
+    end
+end
+
+function gmt.hook(handler)
+    _hook = handler
+end
+
+function gmt.__index(t,name)
+    local found = modules[name]
+    -- either true, or the name of the module containing this class.
+    -- either way, we load the required module and make it globally available.
+    if found then
+        -- e..g pretty.dump causes pl.pretty to become available as 'pretty'
+        rawset(_G,name,require('pl.'..name))
+        return _G[name]
+    else
+        local res
+        if _hook then
+            res = _hook(t,name)
+            if res then return res end
+        end
+        if _prev_index then
+            return _prev_index(t,name)
+        end
+    end
+end
+
+setmetatable(_G,gmt)
+
+if rawget(_G,'PENLIGHT_STRICT') then require 'pl.strict' end