rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/pl/template.lua

@@ -0,0 +1,103 @@
+--- A template preprocessor.
+-- Originally by [Ricki Lake](http://lua-users.org/wiki/SlightlyLessSimpleLuaPreprocessor)
+--
+-- There are two rules:
+--
+--  * lines starting with # are Lua
+--  * otherwise, `$(expr)` is the result of evaluating `expr`
+--
+-- Example:
+--
+--    #  for i = 1,3 do
+--       $(i) Hello, Word!
+--    #  end
+--    ===>
+--    1 Hello, Word!
+--    2 Hello, Word!
+--    3 Hello, Word!
+--
+-- Other escape characters can be used, when the defaults conflict
+-- with the output language.
+--
+--    > for _,n in pairs{'one','two','three'} do
+--    static int l_${n} (luaState *state);
+--    > end
+--
+-- See  @{03-strings.md.Another_Style_of_Template|the Guide}.
+--
+-- Dependencies: `pl.utils`
+-- @module pl.template
+
+local utils = require 'pl.utils'
+local append,format = table.insert,string.format
+
+local function parseHashLines(chunk,brackets,esc)
+    local exec_pat = "()$(%b"..brackets..")()"
+
+    local function parseDollarParen(pieces, chunk, s, e)
+        local s = 1
+        for term, executed, e in chunk:gmatch (exec_pat) do
+            executed = '('..executed:sub(2,-2)..')'
+            append(pieces,
+              format("%q..(%s or '')..",chunk:sub(s, term - 1), executed))
+            s = e
+        end
+        append(pieces, format("%q", chunk:sub(s)))
+    end
+
+    local esc_pat = esc.."+([^\n]*\n?)"
+    local esc_pat1, esc_pat2 = "^"..esc_pat, "\n"..esc_pat
+    local  pieces, s = {"return function(_put) ", n = 1}, 1
+    while true do
+        local ss, e, lua = chunk:find (esc_pat1, s)
+        if not e then
+            ss, e, lua = chunk:find(esc_pat2, s)
+            append(pieces, "_put(")
+            parseDollarParen(pieces, chunk:sub(s, ss))
+            append(pieces, ")")
+            if not e then break end
+        end
+        append(pieces, lua)
+        s = e + 1
+    end
+    append(pieces, " end")
+    return table.concat(pieces)
+end
+
+local template = {}
+
+--- expand the template using the specified environment.
+-- @param str the template string
+-- @param env the environment (by default empty). <br>
+-- There are three special fields in the environment table <ul>
+-- <li><code>_parent</code> continue looking up in this table</li>
+-- <li><code>_brackets</code>; default is '()', can be any suitable bracket pair</li>
+-- <li><code>_escape</code>; default is '#' </li>
+-- </ul>
+function template.substitute(str,env)
+    env = env or {}
+    if rawget(env,"_parent") then
+        setmetatable(env,{__index = env._parent})
+    end
+    local brackets = rawget(env,"_brackets") or '()'
+    local escape = rawget(env,"_escape") or '#'
+    local code = parseHashLines(str,brackets,escape)
+    local fn,err = utils.load(code,'TMP','t',env)
+    if not fn then return nil,err end
+    fn = fn()
+    local out = {}
+    local res,err = xpcall(function() fn(function(s)
+        out[#out+1] = s
+    end) end,debug.traceback)
+    if not res then
+        if env._debug then print(code) end
+        return nil,err
+    end
+    return table.concat(out)
+end
+
+return template
+
+
+
+

data/vendor/lua/lib/lua/pl/test.lua

@@ -0,0 +1,135 @@
+--- Useful test utilities.
+--
+--    test.asserteq({1,2},{1,2}) -- can compare tables
+--    test.asserteq(1.2,1.19,0.02) -- compare FP numbers within precision
+--    T = test.tuple -- used for comparing multiple results
+--    test.asserteq(T(string.find(" me","me")),T(2,3))
+--
+-- Dependencies: `pl.utils`, `pl.tablex`, `pl.pretty`, `pl.path`, `debug`
+-- @module pl.test
+
+local tablex = require 'pl.tablex'
+local utils = require 'pl.utils'
+local pretty = require 'pl.pretty'
+local path = require 'pl.path'
+local print,type = print,type
+local clock = os.clock
+local debug = require 'debug'
+local io,debug = io,debug
+
+local function dump(x)
+    if type(x) == 'table' and not (getmetatable(x) and getmetatable(x).__tostring) then
+        return pretty.write(x,' ',true)
+    elseif type(x) == 'string' then
+        return '"'..x..'"'
+    else
+        return tostring(x)
+    end
+end
+
+local test = {}
+
+local function complain (x,y,msg)
+    local i = debug.getinfo(3)
+    local err = io.stderr
+    err:write(path.basename(i.short_src)..':'..i.currentline..': assertion failed\n')
+    err:write("got:\t",dump(x),'\n')
+    err:write("needed:\t",dump(y),'\n')
+    utils.quit(1,msg or "these values were not equal")
+end
+
+--- general test complain message.
+-- Useful for composing new test functions (see tests/tablex.lua for an example)
+-- @param x a value
+-- @param y value to compare first value against
+-- @param msg message
+test.complain = complain
+
+--- like assert, except takes two arguments that must be equal and can be tables.
+-- If they are plain tables, it will use tablex.deepcompare.
+-- @param x any value
+-- @param y a value equal to x
+-- @param eps an optional tolerance for numerical comparisons
+function test.asserteq (x,y,eps)
+    local res = x == y
+    if not res then
+        res = tablex.deepcompare(x,y,true,eps)
+    end
+    if not res then
+        complain(x,y)
+    end
+end
+
+--- assert that the first string matches the second.
+-- @param s1 a string
+-- @param s2 a string
+function test.assertmatch (s1,s2)
+    if not s1:match(s2) then
+        complain (s1,s2,"these strings did not match")
+    end
+end
+
+--- assert that the function raises a particular error.
+-- @param fn a table of the form {function,arg1,...}
+-- @param e a string to match the error against
+function test.assertraise(fn,e)
+    local ok, err = pcall(unpack(fn))
+    if not err or err:match(e)==nil then
+        complain (err,e,"these errors did not match")
+    end
+end
+
+--- a version of asserteq that takes two pairs of values.
+-- <code>x1==y1 and x2==y2</code> must be true. Useful for functions that naturally
+-- return two values.
+-- @param x1 any value
+-- @param x2 any value
+-- @param y1 any value
+-- @param y2 any value
+function test.asserteq2 (x1,x2,y1,y2)
+    if x1 ~= y1 then complain(x1,y1) end
+    if x2 ~= y2 then complain(x2,y2) end
+end
+
+-- tuple type --
+
+local tuple_mt = {}
+
+function tuple_mt.__tostring(self)
+    local ts = {}
+    for i=1, self.n do
+        local s = self[i]
+        ts[i] = type(s) == 'string' and string.format('%q', s) or tostring(s)
+    end
+    return 'tuple(' .. table.concat(ts, ', ') .. ')'
+end
+
+function tuple_mt.__eq(a, b)
+    if a.n ~= b.n then return false end
+    for i=1, a.n do
+        if a[i] ~= b[i] then return false end
+    end
+    return true
+end
+
+--- encode an arbitrary argument list as a tuple.
+-- This can be used to compare to other argument lists, which is
+-- very useful for testing functions which return a number of values.
+-- @usage asserteq(tuple( ('ab'):find 'a'), tuple(1,1))
+function test.tuple(...)
+    return setmetatable({n=select('#', ...), ...}, tuple_mt)
+end
+
+--- Time a function. Call the function a given number of times, and report the number of seconds taken,
+-- together with a message.  Any extra arguments will be passed to the function.
+-- @param msg a descriptive message
+-- @param n number of times to call the function
+-- @param fun the function
+-- @param ... optional arguments to fun
+function test.timer(msg,n,fun,...)
+    local start = clock()
+    for i = 1,n do fun(...) end
+    utils.printf("%s: took %7.2f sec\n",msg,clock()-start)
+end
+
+return test

data/vendor/lua/lib/lua/pl/text.lua

@@ -0,0 +1,243 @@
+--- Text processing utilities.
+--
+-- This provides a Template class (modeled after the same from the Python
+-- libraries, see string.Template). It also provides similar functions to those
+-- found in the textwrap module.
+--
+-- See  @{03-strings.md.String_Templates|the Guide}.
+--
+-- Calling `text.format_operator()` overloads the % operator for strings to give Python/Ruby style formated output.
+-- This is extended to also do template-like substitution for map-like data.
+--
+--    > require 'pl.text'.format_operator()
+--    > = '%s = %5.3f' % {'PI',math.pi}
+--    PI = 3.142
+--    > = '$name = $value' % {name='dog',value='Pluto'}
+--    dog = Pluto
+--
+-- Dependencies: `pl.utils`
+-- @module pl.text
+
+local gsub = string.gsub
+local concat,append = table.concat,table.insert
+local utils = require 'pl.utils'
+local bind1,usplit,assert_arg,is_callable = utils.bind1,utils.split,utils.assert_arg,utils.is_callable
+
+local function lstrip(str)  return (str:gsub('^%s+',''))  end
+local function strip(str)  return (lstrip(str):gsub('%s+$','')) end
+local function make_list(l)  return setmetatable(l,utils.stdmt.List) end
+local function split(s,delim)  return make_list(usplit(s,delim)) end
+
+local function imap(f,t,...)
+    local res = {}
+    for i = 1,#t do res[i] = f(t[i],...) end
+    return res
+end
+
+--[[
+module ('pl.text',utils._module)
+]]
+
+local text = {}
+
+local function _indent (s,sp)
+    local sl = split(s,'\n')
+    return concat(imap(bind1('..',sp),sl),'\n')..'\n'
+end
+
+--- indent a multiline string.
+-- @param s the string
+-- @param n the size of the indent
+-- @param ch the character to use when indenting (default ' ')
+-- @return indented string
+function text.indent (s,n,ch)
+    assert_arg(1,s,'string')
+    assert_arg(2,s,'number')
+    return _indent(s,string.rep(ch or ' ',n))
+end
+
+--- dedent a multiline string by removing any initial indent.
+-- useful when working with [[..]] strings.
+-- @param s the string
+-- @return a string with initial indent zero.
+function text.dedent (s)
+    assert_arg(1,s,'string')
+    local sl = split(s,'\n')
+    local i1,i2 = sl[1]:find('^%s*')
+    sl = imap(string.sub,sl,i2+1)
+    return concat(sl,'\n')..'\n'
+end
+
+--- format a paragraph into lines so that they fit into a line width.
+-- It will not break long words, so lines can be over the length
+-- to that extent.
+-- @param s the string
+-- @param width the margin width, default 70
+-- @return a list of lines
+function text.wrap (s,width)
+    assert_arg(1,s,'string')
+    width = width or 70
+    s = s:gsub('\n',' ')
+    local i,nxt = 1
+    local lines,line = {}
+    while i < #s do
+        nxt = i+width
+        if s:find("[%w']",nxt) then -- inside a word
+            nxt = s:find('%W',nxt+1) -- so find word boundary
+        end
+        line = s:sub(i,nxt)
+        i = i + #line
+        append(lines,strip(line))
+    end
+    return make_list(lines)
+end
+
+--- format a paragraph so that it fits into a line width.
+-- @param s the string
+-- @param width the margin width, default 70
+-- @return a string
+-- @see wrap
+function text.fill (s,width)
+    return concat(text.wrap(s,width),'\n') .. '\n'
+end
+
+local Template = {}
+text.Template = Template
+Template.__index = Template
+setmetatable(Template, {
+    __call = function(obj,tmpl)
+        return Template.new(tmpl)
+    end})
+
+function Template.new(tmpl)
+    assert_arg(1,tmpl,'string')
+    local res = {}
+    res.tmpl = tmpl
+    setmetatable(res,Template)
+    return res
+end
+
+local function _substitute(s,tbl,safe)
+    local subst
+    if is_callable(tbl) then
+        subst = tbl
+    else
+        function subst(f)
+            local s = tbl[f]
+            if not s then
+                if safe then
+                    return f
+                else
+                    error("not present in table "..f)
+                end
+            else
+                return s
+            end
+        end
+    end
+    local res = gsub(s,'%${([%w_]+)}',subst)
+    return (gsub(res,'%$([%w_]+)',subst))
+end
+
+--- substitute values into a template, throwing an error.
+-- This will throw an error if no name is found.
+-- @param tbl a table of name-value pairs.
+function Template:substitute(tbl)
+    assert_arg(1,tbl,'table')
+    return _substitute(self.tmpl,tbl,false)
+end
+
+--- substitute values into a template.
+-- This version just passes unknown names through.
+-- @param tbl a table of name-value pairs.
+function Template:safe_substitute(tbl)
+    assert_arg(1,tbl,'table')
+    return _substitute(self.tmpl,tbl,true)
+end
+
+--- substitute values into a template, preserving indentation. <br>
+-- If the value is a multiline string _or_ a template, it will insert
+-- the lines at the correct indentation. <br>
+-- Furthermore, if a template, then that template will be subsituted
+-- using the same table.
+-- @param tbl a table of name-value pairs.
+function Template:indent_substitute(tbl)
+    assert_arg(1,tbl,'table')
+    if not self.strings then
+        self.strings = split(self.tmpl,'\n')
+    end
+    -- the idea is to substitute line by line, grabbing any spaces as
+    -- well as the $var. If the value to be substituted contains newlines,
+    -- then we split that into lines and adjust the indent before inserting.
+    local function subst(line)
+        return line:gsub('(%s*)%$([%w_]+)',function(sp,f)
+			local subtmpl
+            local s = tbl[f]
+            if not s then error("not present in table "..f) end
+			if getmetatable(s) == Template then
+				subtmpl = s
+				s = s.tmpl
+			else
+				s = tostring(s)
+			end
+            if s:find '\n' then
+                s = _indent(s,sp)
+            end
+			if subtmpl then return _substitute(s,tbl)
+			else return s
+			end
+        end)
+    end
+    local lines = imap(subst,self.strings)
+    return concat(lines,'\n')..'\n'
+end
+
+------- Python-style formatting operator ------
+-- (see <a href="http://lua-users.org/wiki/StringInterpolation">the lua-users wiki</a>) --
+
+function text.format_operator()
+
+    local format = string.format
+
+    -- a more forgiving version of string.format, which applies
+    -- tostring() to any value with a %s format.
+    local function formatx (fmt,...)
+        local args = {...}
+        local i = 1
+        for p in fmt:gmatch('%%.') do
+            if p == '%s' and type(args[i]) ~= 'string' then
+                args[i] = tostring(args[i])
+            end
+            i = i + 1
+        end
+        return format(fmt,unpack(args))
+    end
+
+    local function basic_subst(s,t)
+        return (s:gsub('%$([%w_]+)',t))
+    end
+
+    -- Note this goes further than the original, and will allow these cases:
+    -- 1. a single value
+    -- 2. a list of values
+    -- 3. a map of var=value pairs
+    -- 4. a function, as in gsub
+    -- For the second two cases, it uses $-variable substituion.
+    getmetatable("").__mod = function(a, b)
+        if b == nil then
+            return a
+        elseif type(b) == "table" and getmetatable(b) == nil then
+            if #b == 0 then -- assume a map-like table
+                return _substitute(a,b,true)
+            else
+                return formatx(a,unpack(b))
+            end
+        elseif type(b) == 'function' then
+            return basic_subst(a,b)
+        else
+            return formatx(a,b)
+        end
+    end
+end
+
+return text