rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/fstable.lua

@@ -0,0 +1,116 @@
+--- Tables mapped to the filing system
+-- Only string keys are permitted; package.dirsep characters are
+-- converted to underscores.
+-- Values are stored as strings (converted by tostring).
+-- As with disk operations, a table's elements must be set to nil
+-- (deleted) before the table itself can be set to nil.
+module ("fstable", package.seeall)
+
+require "io_ext"
+require "table_ext"
+
+require "io_ext"
+require "lfs"
+require "posix"
+
+local function fsnext (dir)
+  local f
+  repeat
+    f = dir:next ()
+  until f ~= "." and f ~= ".."
+  return f
+end
+
+-- Metamethods for persistent tables
+local metatable = {}
+
+metatable.__index =
+function (t, k)
+  local path = io.catfile (getmetatable (t).directory, k)
+  local attrs = lfs.attributes (path)
+  if attrs then
+    if attrs.mode == "file" then
+      return io.slurp (path)
+    elseif attrs.mode == "directory" then
+      return new (path)
+    end
+  end
+  return attrs
+end
+
+metatable.__newindex =
+function (t, k, v)
+  local ty = type (v)
+  if ty == "thread" or ty == "function" or ty == "userdata" then
+    error ("cannot persist a " .. ty .. "")
+  elseif type (k) ~= "string" then
+    error ("keys of persistent tables must be of type string")
+  else
+    k = string.gsub (k, package.dirsep, "_")
+    local path = io.catfile (getmetatable (t).directory, k)
+    local vm = getmetatable (v)
+    if v == nil then
+      os.remove (path)
+    elseif type (v) ~= "table" then
+      local h = io.open (path, "w")
+      h:write (tostring (v))
+      h:close ()
+    elseif type (vm) == "table" and vm.metatable == metatable then
+      -- To match Lua semantics we'd hardlink, but that's not allowed for directories
+      local ok, errmsg = posix.link (vm.directory, path, true)
+    else
+      local ok, errmsg = lfs.mkdir (path)
+      if not ok then
+        error (errmsg)
+      end
+      new (path, v)
+    end
+  end
+end
+
+metatable.__pairs =
+function (t)
+  local _, dir = lfs.dir (getmetatable (t).directory)
+  return function (dir)
+           local f = fsnext (dir)
+           if f then
+             return f, t[f]
+           end
+         end,
+  dir
+end
+
+metatable.__ipairs =
+function (t)
+  local _, dir = lfs.dir (getmetatable (t).directory)
+  return function (dir, i)
+           local f = fsnext (dir)
+           if f then
+             return i + 1, f
+           end
+         end,
+  dir, 0
+end
+
+--- Bind a directory to a table
+-- @param path directory path
+-- @param t table to merge with directory
+-- @return table bound to directory
+function new (path, t)
+  if not path:find ("^" .. package.dirsep) then
+    path = io.catfile (lfs.currentdir (), path)
+  end
+  if lfs.attributes (path, "mode") ~= "directory" then
+    error ("`" .. path .. "' does not exist or is not a directory")
+  end
+  local m = table.clone (metatable)
+  m.directory = path
+  m.metatable = metatable
+  local d = setmetatable ({}, m)
+  if t then
+    for i, v in pairs (t) do
+      d[i] = v
+    end
+  end
+  return d
+end

data/vendor/lua/lib/lua/getopt.lua

@@ -0,0 +1,273 @@
+--- Simplified getopt, based on Svenne Panne's Haskell GetOpt.<br>
+-- Usage:
+-- <ul>
+-- <li><code>options = {Option {...}, ...}</br>
+-- getopt.processArgs ()</code></li>
+-- <li>Assumes <code>prog = {name[, banner] [, purpose] [, notes] [, usage]}</code></li>
+-- <li>Options take a single dash, but may have a double dash.</li>
+-- <li>Arguments may be given as <code>-opt=arg</code> or <code>-opt arg</code>.</li>
+-- <li>If an option taking an argument is given multiple times, only the
+-- last value is returned; missing arguments are returned as 1.</li>
+-- </ul>
+-- getOpt, usageInfo and usage can be called directly (see
+-- below, and the example at the end). Set _DEBUG.std to a non-nil
+-- value to run the example.
+-- <ul>
+-- <li>TODO: Sort out the packaging. getopt.Option is tedious to type, but
+-- surely Option shouldn't be in the root namespace?</li>
+-- <li>TODO: Wrap all messages; do all wrapping in processArgs, not
+-- usageInfo; use sdoc-like library (see string.format todos).</li>
+-- <li>TODO: Don't require name to be repeated in banner.</li>
+-- <li>TODO: Store version separately (construct banner?).</li>
+-- </ul>
+module ("getopt", package.seeall)
+
+require "base"
+require "list"
+require "string_ext"
+require "object"
+
+
+--- Perform argument processing
+-- @param argIn list of command-line args
+-- @param options options table
+-- @return table of remaining non-options
+-- @return table of option key-value list pairs
+-- @return table of error messages
+function getOpt (argIn, options)
+  local noProcess = nil
+  local argOut, optOut, errors = {[0] = argIn[0]}, {}, {}
+  -- get an argument for option opt
+  local function getArg (o, opt, arg, oldarg)
+    if o.type == nil then
+      if arg ~= nil then
+        table.insert (errors, "option `" .. opt .. "' doesn't take an argument")
+      end
+    else
+      if arg == nil and argIn[1] and
+        string.sub (argIn[1], 1, 1) ~= "-" then
+        arg = argIn[1]
+        table.remove (argIn, 1)
+      end
+      if arg == nil and o.type == "Req" then
+        table.insert (errors,  "option `" .. opt ..
+                      "' requires an argument `" .. o.var .. "'")
+        return nil
+      end
+    end
+    return arg or 1 -- make sure arg has a value
+  end
+
+  local function parseOpt (opt, arg)
+    local o = options.name[opt]
+    if o ~= nil then
+      optOut[o.name[1]] = optOut[o.name[1]] or {}
+      table.insert (optOut[o.name[1]], getArg (o, opt, arg, optOut[o.name[1]]))
+    else
+      table.insert (errors, "unrecognized option `-" .. opt .. "'")
+    end
+  end
+  while argIn[1] do
+    local v = argIn[1]
+    table.remove (argIn, 1)
+    local _, _, dash, opt = string.find (v, "^(%-%-?)([^=-][^=]*)")
+    local _, _, arg = string.find (v, "=(.*)$")
+    if v == "--" then
+      noProcess = 1
+    elseif dash == nil or noProcess then -- non-option
+      table.insert (argOut, v)
+    else -- option
+      parseOpt (opt, arg)
+    end
+  end
+  return argOut, optOut, errors
+end
+
+
+--- Options table type.
+-- @class table
+-- @name _G.Option
+-- @field name list of names
+-- @field desc description of this option
+-- @field type type of argument (if any): <code>Req</code>(uired),
+-- <code>Opt</code>(ional)
+-- @field var descriptive name for the argument
+_G.Option = Object {_init = {"name", "desc", "type", "var"}}
+
+--- Options table constructor: adds lookup tables for the option names
+local function makeOptions (t)
+  t = list.concat (t or {},
+                   {Option {{"version", "V"},
+                            "output version information and exit"},
+                    Option {{"help", "h"},
+                            "display this help and exit"}}
+               )
+  local name = {}
+  for v in list.elems (t) do
+    for j, s in pairs (v.name) do
+      if name[s] then
+        warn ("duplicate option '%s'", s)
+      end
+      name[s] = v
+    end
+  end
+  t.name = name
+  return t
+end
+
+
+--- Produce usage info for the given options
+-- @param header header string
+-- @param optDesc option descriptors
+-- @param pageWidth width to format to [78]
+-- @return formatted string
+function usageInfo (header, optDesc, pageWidth)
+  pageWidth = pageWidth or 78
+  -- Format the usage info for a single option
+  -- @param opt the Option table
+  -- @return options
+  -- @return description
+  local function fmtOpt (opt)
+    local function fmtName (o)
+      return "-" .. o
+    end
+    local function fmtArg ()
+      if opt.type == nil then
+        return ""
+      elseif opt.type == "Req" then
+        return "=" .. opt.var
+      else
+        return "[=" .. opt.var .. "]"
+      end
+    end
+    local textName = list.reverse (list.map (fmtName, opt.name))
+    textName[#textName] = textName[#textName] .. fmtArg ()
+    return {table.concat ({table.concat (textName, ", ")}, ", "),
+      opt.desc}
+  end
+  local function sameLen (xs)
+    local n = math.max (unpack (list.map (string.len, xs)))
+    for i, v in pairs (xs) do
+      xs[i] = string.sub (v .. string.rep (" ", n), 1, n)
+    end
+    return xs, n
+  end
+  local function paste (x, y)
+    return "  " .. x .. "  " .. y
+  end
+  local function wrapper (w, i)
+    return function (s)
+             return string.wrap (s, w, i, 0)
+           end
+  end
+  local optText = ""
+  if #optDesc > 0 then
+    local cols = list.transpose (list.map (fmtOpt, optDesc))
+    local width
+    cols[1], width = sameLen (cols[1])
+    cols[2] = list.map (wrapper (pageWidth, width + 4), cols[2])
+    optText = "\n\n" ..
+      table.concat (list.mapWith (paste,
+                                  list.transpose ({sameLen (cols[1]),
+                                                    cols[2]})),
+                    "\n")
+  end
+  return header .. optText
+end
+
+--- Emit a usage message.
+function usage ()
+  local usage, purpose, notes = "[OPTION]... [FILE]...", "", ""
+  if prog.usage then
+    usage = prog.usage
+  end
+  if prog.purpose then
+    purpose = "\n" .. prog.purpose
+  end
+  if prog.notes then
+    notes = "\n\n"
+    if not string.find (prog.notes, "\n") then
+      notes = notes .. string.wrap (prog.notes)
+    else
+      notes = notes .. prog.notes
+    end
+  end
+  io.writelines (getopt.usageInfo ("Usage: " .. prog.name .. " " .. usage .. purpose,
+                                   options)
+                 .. notes)
+end
+
+
+--- Simple getOpt wrapper.
+-- Adds <code>-version</code>/<code>-V</code> and
+-- <code>-help</code>/<code>-h</code> automatically;
+-- stops program if there was an error, or if <code>-help</code> or
+-- <code>-version</code> was used.
+function processArgs ()
+  local totArgs = #arg
+  options = makeOptions (options)
+  local errors
+  _G.arg, opt, errors = getopt.getOpt (arg, options)
+  if (opt.version or opt.help) and prog.banner then
+    io.writelines (prog.banner)
+  end
+  if #errors > 0 or opt.help then
+    local name = prog.name
+    prog.name = nil
+    if #errors > 0 then
+      warn (table.concat (errors, "\n") .. "\n")
+    end
+    prog.name = name
+    getopt.usage ()
+    if #errors > 0 then
+      error ()
+    end
+  end
+  if opt.version or opt.help then
+    os.exit ()
+  end
+end
+_G.options = nil
+
+
+-- A small and hopefully enlightening example:
+if type (_DEBUG) == "table" and _DEBUG.std then
+
+  options = makeOptions ({
+                           Option {{"verbose", "v"}, "verbosely list files"},
+                           Option {{"output", "o"}, "dump to FILE", "Opt", "FILE"},
+                           Option {{"name", "n"}, "only dump USER's files", "Req", "USER"},
+                       })
+
+  function test (cmdLine)
+    local nonOpts, opts, errors = getopt.getOpt (cmdLine, options)
+    if #errors == 0 then
+      print ("options=" .. tostring (opts) ..
+             "  args=" .. tostring (nonOpts) .. "\n")
+    else
+      print (table.concat (errors, "\n") .. "\n" ..
+             getopt.usageInfo ("Usage: foobar [OPTION...] FILE...",
+                               options))
+    end
+  end
+
+  -- FIXME: Turn the following documentation into unit tests
+  prog = {name = "foobar"} -- for errors
+  -- Example runs:
+  test {"foo", "-v"}
+  -- options={verbose={1}}  args={1=foo}
+  test {"foo", "--", "-v"}
+  -- options={}  args={1=foo,2=-v}
+  test {"-o", "-V", "-name", "bar", "--name=baz"}
+  -- options={name={"baz"},version={1},output={1}}  args={}
+  test {"-foo"}
+  -- unrecognized option `-foo'
+  -- Usage: foobar [OPTION]... [FILE]...
+  --
+  --   -v, -verbose                verbosely list files
+  --   -o, -output[=FILE]          dump to FILE
+  --   -n, -name=USER              only dump USER's files
+  --   -V, -version                output version information and exit
+  --   -h, -help                   display this help and exit
+
+end

data/vendor/lua/lib/lua/git.lua

@@ -0,0 +1,5 @@
+require 'git.util'
+require 'git.objects'
+require 'git.pack'
+require 'git.repo'
+require 'git.protocol'

data/vendor/lua/lib/lua/git/objects.lua

@@ -0,0 +1,121 @@
+local util = require 'git.util'
+
+local assert, next, io, print, os, type, string, pairs, tostring =
+	assert, next, io, print, os, type, string, pairs, tostring
+local join_path = git.util.join_path
+
+local require = require
+
+local isPosix = package.config:sub(1,1) == '/' -- wild guess
+
+module(...)
+
+Commit = {}
+Commit.__index = Commit
+
+function Commit:tree()
+	return self.repo:tree(self.tree_sha)
+end
+
+function Commit:checkout(path)
+	assert(path, 'path argument missing')
+	self:tree():checkoutTo(path)
+end
+
+
+Tree = {}
+Tree.__index = function (t,k)
+	if Tree[k] then return Tree[k] end
+	return t:entry(k)
+end
+
+function Tree:entries()
+	return function(t, n)
+		local n, entry = next(t, n)
+		if entry then
+			local object
+			if entry.type == 'tree' then
+				object = self.repo:tree(entry.id)
+			elseif entry.type == 'blob' then
+				object = self.repo:blob(entry.id)
+				object.mode = entry.mode
+			elseif entry.type == 'commit' then
+				-- this is possibly a commit in a submodule, 
+				-- do not retrieve it from current repo
+				object = entry
+			else
+				error('Unknown entry type: ' .. entry.type)
+			end
+			return n, entry.type, object
+		end
+	end, self._entries
+end
+
+function Tree:entry(n)
+	local e = self._entries[n]
+	if not e then return end
+	if e.type == 'tree' then
+		return self.repo:tree(e.id)
+	elseif e.type == 'commit' then
+		return self.repo:commit(e.id)
+	elseif e.type == 'blob' then
+		return self.repo:blob(e.id)
+	else
+		error('Unknown entry type: ' .. e.type)
+	end
+end
+
+function Tree:walk(func, path)
+	path = path or '.'
+	assert(type(func) == "function", "argument is not a function")
+	local function walk(tree, path)
+		for name, type, entry in tree:entries() do
+			local entry_path = join_path(path, name)
+			func(entry, entry_path, type)
+
+			if type == "tree" then
+				walk(entry, entry_path)
+			end
+		end
+	end
+	walk(self, path)
+end
+
+function Tree:checkoutTo(path)
+	util.make_dir(path)
+	self:walk(function (entry, entry_path, type)
+		if type == 'tree' then
+			util.make_dir(entry_path)
+		elseif type == 'blob' then
+			local out = assert(io.open(entry_path, 'wb'))
+			out:write(entry:content())
+			out:close()
+			if isPosix then
+				local mode = entry.mode:sub(-3,-1) -- fixme: is this ok?
+				local cmd = 'chmod '..mode..' "'..entry_path..'"'
+				os.execute(cmd)
+			end
+		elseif type == 'commit' then
+			-- this is a submodule referencing a commit,
+			-- make a directory for it
+			util.make_dir(entry_path)
+		else
+			error('Unknown entry type: ', type)
+		end
+	end, path)
+end
+
+Blob = {}
+Blob.__index = Blob
+
+function Blob:content()
+	if self.stored then
+		local f = self.repo:raw_object(self.id)
+		local ret = f:read('*a') or ""
+		f:close()
+		return ret
+	else
+		return self.data
+	end
+end
+