rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/pl/Map.lua

@@ -0,0 +1,113 @@
+--- A Map class.
+--
+--    > Map = require 'pl.Map'
+--    > m = Map{one=1,two=2}
+--    > m:update {three=3,four=4,two=20}
+--    > = m == M{one=1,two=20,three=3,four=4}
+--    true
+--
+-- Dependencies: `pl.utils`, `pl.class`, `pl.tablex`, `pl.pretty`
+-- @module pl.Map
+
+local tablex = require 'pl.tablex'
+local utils = require 'pl.utils'
+local stdmt = utils.stdmt
+local is_callable = utils.is_callable
+local tmakeset,deepcompare,merge,keys,difference,tupdate = tablex.makeset,tablex.deepcompare,tablex.merge,tablex.keys,tablex.difference,tablex.update
+
+local pretty_write = require 'pl.pretty' . write
+local Map = stdmt.Map
+local Set = stdmt.Set
+local List = stdmt.List
+
+local class = require 'pl.class'
+
+-- the Map class ---------------------
+class(nil,nil,Map)
+
+local function makemap (m)
+    return setmetatable(m,Map)
+end
+
+function Map:_init (t)
+    local mt = getmetatable(t)
+    if mt == Set or mt == Map then
+        self:update(t)
+    else
+        return t -- otherwise assumed to be a map-like table
+    end
+end
+
+
+local function makelist(t)
+    return setmetatable(t,List)
+end
+
+--- list of keys.
+Map.keys = tablex.keys
+
+--- list of values.
+Map.values = tablex.values
+
+--- return an iterator over all key-value pairs.
+function Map:iter ()
+    return pairs(self)
+end
+
+--- return a List of all key-value pairs, sorted by the keys.
+function Map:items()
+    local ls = makelist(tablex.pairmap (function (k,v) return makelist {k,v} end, self))
+	ls:sort(function(t1,t2) return t1[1] < t2[1] end)
+	return ls
+end
+
+-- Will return the existing value, or if it doesn't exist it will set
+-- a default value and return it.
+function Map:setdefault(key, defaultval)
+   return self[key] or self:set(key,defaultval) or defaultval
+end
+
+--- size of map.
+-- note: this is a relatively expensive operation!
+-- @class function
+-- @name Map:len
+Map.len = tablex.size
+
+--- put a value into the map.
+-- @param key the key
+-- @param val the value
+function Map:set (key,val)
+    self[key] = val
+end
+
+--- get a value from the map.
+-- @param key the key
+-- @return the value, or nil if not found.
+function Map:get (key)
+    return rawget(self,key)
+end
+
+local index_by = tablex.index_by
+
+--- get a list of values indexed by a list of keys.
+-- @param keys a list-like table of keys
+-- @return a new list
+function Map:getvalues (keys)
+    return makelist(index_by(self,keys))
+end
+
+--- update the map using key/value pairs from another table.
+-- @param table
+-- @function Map:update
+Map.update = tablex.update
+
+function Map:__eq (m)
+    -- note we explicitly ask deepcompare _not_ to use __eq!
+    return deepcompare(self,m,true)
+end
+
+function Map:__tostring ()
+    return pretty_write(self,'')
+end
+
+return Map

data/vendor/lua/lib/lua/pl/MultiMap.lua

@@ -0,0 +1,62 @@
+--- MultiMap, a Map which has multiple values per key.
+--
+-- Dependencies: `pl.utils`, `pl.class`, `pl.tablex`, `pl.List`
+-- @module pl.MultiMap
+
+local classes = require 'pl.class'
+local tablex = require 'pl.tablex'
+local utils = require 'pl.utils'
+local List = require 'pl.List'
+
+local index_by,tsort,concat = tablex.index_by,table.sort,table.concat
+local append,extend,slice = List.append,List.extend,List.slice
+local append = table.insert
+local is_type = utils.is_type
+
+local class = require 'pl.class'
+local Map = require 'pl.Map'
+
+-- MultiMap is a standard MT
+local MultiMap = utils.stdmt.MultiMap
+
+class(Map,nil,MultiMap)
+MultiMap._name = 'MultiMap'
+
+function MultiMap:_init (t)
+    if not t then return end
+    self:update(t)
+end
+
+--- update a MultiMap using a table.
+-- @param t either a Multimap or a map-like table.
+-- @return the map
+function MultiMap:update (t)
+    utils.assert_arg(1,t,'table')
+    if Map:class_of(t) then
+        for k,v in pairs(t) do
+            self[k] = List()
+            self[k]:append(v)
+        end
+    else
+        for k,v in pairs(t) do
+            self[k] = List(v)
+        end
+    end
+end
+
+--- add a new value to a key.  Setting a nil value removes the key.
+-- @param key the key
+-- @param val the value
+-- @return the map
+function MultiMap:set (key,val)
+    if val == nil then
+        self[key] = nil
+    else
+        if not self[key] then
+            self[key] = List()
+        end
+        self[key]:append(val)
+    end
+end
+
+return MultiMap

data/vendor/lua/lib/lua/pl/OrderedMap.lua

@@ -0,0 +1,151 @@
+--- OrderedMap, a map which preserves ordering.
+--
+-- Derived from `pl.Map`.
+--
+-- Dependencies: `pl.utils`, `pl.tablex`, `pl.List`
+-- @module pl.OrderedMap
+
+local tablex = require 'pl.tablex'
+local utils = require 'pl.utils'
+local List = require 'pl.List'
+local index_by,tsort,concat = tablex.index_by,table.sort,table.concat
+
+local class = require 'pl.class'
+local Map = require 'pl.Map'
+
+local OrderedMap = class(Map)
+OrderedMap._name = 'OrderedMap'
+
+--- construct an OrderedMap.
+-- Will throw an error if the argument is bad.
+-- @param t optional initialization table, same as for @{OrderedMap:update}
+function OrderedMap:_init (t)
+    self._keys = List()
+    if t then
+        local map,err = self:update(t)
+        if not map then error(err,2) end
+    end
+end
+
+local assert_arg,raise = utils.assert_arg,utils.raise
+
+--- update an OrderedMap using a table.
+-- If the table is itself an OrderedMap, then its entries will be appended. <br>
+-- if it s a table of the form <code>{{key1=val1},{key2=val2},...}</code> these will be appended. <br>
+-- Otherwise, it is assumed to be a map-like table, and order of extra entries is arbitrary.
+-- @param t a table.
+-- @return the map, or nil in case of error
+-- @return the error message
+function OrderedMap:update (t)
+    assert_arg(1,t,'table')
+    if OrderedMap:class_of(t) then
+       for k,v in t:iter() do
+           self:set(k,v)
+       end
+    elseif #t > 0 then -- an array must contain {key=val} tables
+       if type(t[1]) == 'table' then
+           for _,pair in ipairs(t) do
+               local key,value = next(pair)
+               if not key then return raise 'empty pair initialization table' end
+               self:set(key,value)
+           end
+       else
+           return raise 'cannot use an array to initialize an OrderedMap'
+       end
+    else
+       for k,v in pairs(t) do
+           self:set(k,v)
+       end
+    end
+   return self
+end
+
+--- set the key's value.   This key will be appended at the end of the map. <br>
+-- If the value is nil, then the key is removed.
+-- @param key the key
+-- @param val the value
+-- @return the map
+function OrderedMap:set (key,val)
+    if not self[key] and val ~= nil then -- ensure that keys are unique
+       self._keys:append(key)
+    elseif val == nil then -- removing a key-value pair
+       self._keys:remove_value(key)
+    end
+    self[key] = val
+    return self
+end
+
+--- insert a key/value pair before a given position.
+-- Note: if the map already contains the key, then this effectively
+-- moves the item to the new position by first removing at the old position.
+-- Has no effect if the key does not exist and val is nil
+-- @param pos a position starting at 1
+-- @param key the key
+-- @param val the value; if nil use the old value
+function OrderedMap:insert (pos,key,val)
+    local oldval = self[key]
+    val = val or oldval
+    if oldval then
+        self._keys:remove_value(key)
+    end
+    if val then
+        self._keys:insert(pos,key)
+        self[key] = val
+    end
+    return self
+end
+
+--- return the keys in order.
+-- (Not a copy!)
+-- @return List
+function OrderedMap:keys ()
+    return self._keys
+end
+
+--- return the values in order.
+-- this is relatively expensive.
+-- @return List
+function OrderedMap:values ()
+    return List(index_by(self,self._keys))
+end
+
+--- sort the keys.
+-- @param cmp a comparison function as for @{table.sort}
+-- @return the map
+function OrderedMap:sort (cmp)
+    tsort(self._keys,cmp)
+    return self
+end
+
+--- iterate over key-value pairs in order.
+function OrderedMap:iter ()
+    local i = 0
+    local keys = self._keys
+    local n,idx = #keys
+    return function()
+        i = i + 1
+        if i > #keys then return nil end
+        idx = keys[i]
+        return idx,self[idx]
+    end
+end
+
+OrderedMap.__pairs = OrderedMap.iter
+
+function OrderedMap:__tostring ()
+    local res = {}
+    for i,v in ipairs(self._keys) do
+        local val = self[v]
+        local vs = tostring(val)
+        if type(val) ~= 'number' then
+            vs = '"'..vs..'"'
+        end
+        res[i] = tostring(v)..'='..vs
+    end
+    return '{'..concat(res,',')..'}'
+end
+
+return OrderedMap
+
+
+

data/vendor/lua/lib/lua/pl/Set.lua

@@ -0,0 +1,153 @@
+--- A Set class.
+--
+--     > Set = require 'pl.Set'
+--     > = Set{'one','two'} == Set{'two','one'}
+--     true
+--     > fruit = Set{'apple','banana','orange'}
+--     > = fruit['banana']
+--     true
+--     > = fruit['hazelnut']
+--     nil
+--     > colours = Set{'red','orange','green','blue'}
+--     > = fruit,colours
+--     [apple,orange,banana]   [blue,green,orange,red]
+--     > = fruit+colours
+--     [blue,green,apple,red,orange,banana]
+--     > = fruit*colours
+--     [orange]
+--
+-- Depdencies: `pl.utils`, `pl.tablex`, `pl.class`
+-- @module pl.Set
+
+local tablex = require 'pl.tablex'
+local utils = require 'pl.utils'
+local stdmt = utils.stdmt
+local tmakeset,deepcompare,merge,keys,difference,tupdate = tablex.makeset,tablex.deepcompare,tablex.merge,tablex.keys,tablex.difference,tablex.update
+local Map = require 'pl.Map'
+local Set = stdmt.Set
+local List = stdmt.List
+local class = require 'pl.class'
+
+-- the Set class --------------------
+class(Map,nil,Set)
+
+-- note: Set has _no_ methods!
+Set.__index = nil
+
+local function makeset (t)
+    return setmetatable(t,Set)
+end
+
+--- create a set. <br>
+-- @param t may be a Set, Map or list-like table.
+-- @class function
+-- @name Set
+function Set:_init (t)
+    local mt = getmetatable(t)
+    if mt == Set or mt == Map then
+        for k in pairs(t) do self[k] = true end
+    else
+        for _,v in ipairs(t) do self[v] = true end
+    end
+end
+
+function Set:__tostring ()
+    return '['..Set.values(self):join ','..']'
+end
+
+--- get a list of the values in a set.
+-- @param self a Set
+-- @function Set.values
+Set.values = Map.keys
+
+--- map a function over the values of a set.
+-- @param self a Set
+-- @param fn a function
+-- @param ... extra arguments to pass to the function.
+-- @return a new set
+function Set.map (self,fn,...)
+    fn = utils.function_arg(1,fn)
+    local res = {}
+    for k in pairs(self) do
+        res[fn(k,...)] = true
+    end
+    return makeset(res)
+end
+
+--- union of two sets (also +).
+-- @param self a Set
+-- @param set another set
+-- @return a new set
+function Set.union (self,set)
+    return merge(self,set,true)
+end
+Set.__add = Set.union
+
+--- intersection of two sets (also *).
+-- @param self a Set
+-- @param set another set
+-- @return a new set
+function Set.intersection (self,set)
+    return merge(self,set,false)
+end
+Set.__mul = Set.intersection
+
+--- new set with elements in the set that are not in the other (also -).
+-- @param self a Set
+-- @param set another set
+-- @return a new set
+function Set.difference (self,set)
+    return difference(self,set,false)
+end
+Set.__sub = Set.difference
+
+-- a new set with elements in _either_ the set _or_ other but not both (also ^).
+-- @param self a Set
+-- @param set another set
+-- @return a new set
+function Set.symmetric_difference (self,set)
+    return difference(self,set,true)
+end
+Set.__pow = Set.symmetric_difference
+
+--- is the first set a subset of the second (also <)?.
+-- @param self a Set
+-- @param set another set
+-- @return true or false
+function Set.issubset (self,set)
+    for k in pairs(self) do
+        if not set[k] then return false end
+    end
+    return true
+end
+Set.__lt = Set.subset
+
+--- is the set empty?.
+-- @param self a Set
+-- @return true or false
+function Set.issempty (self)
+    return next(self) == nil
+end
+
+--- are the sets disjoint? (no elements in common).
+-- Uses naive definition, i.e. that intersection is empty
+-- @param s1 a Set
+-- @param s2 another set
+-- @return true or false
+function Set.isdisjoint (s1,s2)
+    return Set.isempty(Set.intersection(s1,s2))
+end
+
+--- size of this set (also # for 5.2).
+-- @param s a Set
+-- @return size
+-- @function Set.len
+Set.len = tablex.size
+
+Set.__len = Set.len
+
+function Set.__eq (s1,s2)
+    return Set.issubset(s1,s2) and Set.issubset(s2,s1)
+end
+
+return Set