path: root/lib/gitano/util.lua

-- gitano.util
--
-- Low level utility routines for Gitano
--
-- Copyright 2012 Daniel Silverstone <dsilvers@digital-scurf.org>
--
--

local luxio = require 'luxio'
local sio = require 'luxio.simple'

local tconcat = table.concat

local function _deep_copy(t, memo)
   if not memo then memo = {} end
   if memo[t] then return memo[t] end
   local ret = {}
   local kk, vv
   for k, v in pairs(t) do
      kk, vv = k, v
      if type(k) == "table" then
	 kk = _deep_copy(k, memo)
      end
      if type(v) == "table" then
	 vv = _deep_copy(v, memo)
      end
      ret[kk] = vv
   end
   return ret
end

local function _parse_cmdline(cmdline)
   local r = {}
   local acc = ""
   local c
   local escaping = false
   local quoting = false
   while #cmdline > 0 do
      c, cmdline = cmdline:match("^(.)(.*)$")
      if escaping then 
	 if c == "n" then
	    acc = acc .. "\n"
	 elseif c == "t" then
	    acc = acc .. "\t"
	 else
	    acc = acc .. c
	 end
	 escaping = false
      else
	 if c == "'" and quoting == false then
	    -- Start single quotes
	    quoting = c
	 elseif c == '"' and quoting == false then
	    -- Start double quotes
	    quoting = c
	 elseif c == "'" and quoting == c then
	    -- End single quotes
	    quoting = false
	 elseif c == '"' and quoting == c then
	    -- End double quotes
	    quoting = false
	 elseif c == "\\" then
	    -- A backslash, entering escaping mode
	    escaping = true
	 elseif quoting then
	    -- Within quotes, so accumulate
	    acc = acc .. c
	 elseif c == " " then
	    -- A space and not quoting, so clear the accumulator
	    if acc ~= "" then
	       r[#r+1] = acc
	    end
	    acc = ""
	 else
	    acc = acc .. c
	 end
      end
   end
   if acc ~= "" then
      r[#r+1] = acc
   end

   local warnings = {}
   if quoting then
      warnings[#warnings+1] = "Un-terminated quoted string"
   end
   if escaping then
      warnings[#warnings+1] = "Un-used escape at end"
   end
   if #r == 0 then
      warnings[#warnings+1] = "No command found?"
   end

   return r, warnings
end

local function patesc(s)
   return ((s:gsub("[%%%*%-%?%.%+%[%]%(%)]", "%%%0"):gsub("%z", "%%z")))
end

local function path_components(path)
   local ret = {}
   for elem in path:gmatch("([^/]*)/*") do
      ret[#ret+1] = elem
   end
   ret[#ret] = nil
   return ret
end

local function dirname(path)
   local t = path_components(path)
   t[#t] = nil
   return table.concat(t, "/")
end

local function basename(path, ext)
   local t = path_components(path)
   local ret = t[#t]
   if ext then
      local pat = patesc(ext) .. "$"
      if ret:find(pat) then
	 ret = ret:sub(1, -(#ext+1))
      end
   end
   return ret
end

local function mkdir_p(path, mode)
   if not mode then
      mode = sio.tomode("0755")
   end

   if path == "" or path == "/" then
      return true
   end

   if path:find("/") then
      local ok, msg = mkdir_p(dirname(path))
      if not ok then
	 return ok, msg
      end
   end

   local r, err = luxio.mkdir(path, mode)
   if r < 0 then
      if err == luxio.EEXIST then
	 return true
      end
      return nil, "mkdir(" .. path .. "): " .. luxio.strerror(err)
   end
   return true
end

local function rm_rf(path)
   local ret, err, dirp
   dirp, err = luxio.opendir(path)
   if not dirp then
      return false, luxio.strerror(err)
   end
   local e, i
   repeat
      e, i = luxio.readdir(dirp)
      if e == 0 then
	 if i.d_name ~= "." and i.d_name ~= ".." then
	    local elem = path .. "/" .. i.d_name
	    ret, err = luxio.unlink(elem)
	    if ret ~= 0 and err == luxio.EISDIR then
	       ret, err = rm_rf(elem)
	       if not ret then
		  return ret, err
	       end
	    elseif ret ~= 0 then
	       return false, luxio.strerror(err)
	    end
	 end
      end
   until not e

   -- explicitly close the dir so we can remove it
   luxio.closedir(dirp)
   ret, err = luxio.rmdir(path)
   return (ret == 0), luxio.strerror(err)
end

local function html_escape(s)
   return (s:gsub("&", "&amp;"):
	   gsub("<", "&lt;"):
	   gsub(">", "&gt;"):
	   gsub('"', "&quot;"))
end

local tagname_pattern = "^[a-z0-9_%-/]*[a-z0-9_%-]*$"

local function prep_expansion(str)
   -- Parse 'str' and return a table representing a sequence of
   -- operations required to evaluate the expansion of the string.
   -- in the simple case, it's merely the string in a table
   -- if the entry in ret is a string, it's copied.  If it's a table
   -- then that table's [1] is a string which is a tag name to expand.
   local ret = {}
   local acc = ""
   local c
   local seen = false
   while #str > 0 do
      c, str = str:match("^(.)(.*)$")
      if seen == false then
	 if c == "$" then
	    seen = c
	 else
	    acc = acc .. c
	 end
      elseif seen == "$" then
	 if c == "{" then
	    seen = c
	    if acc ~= "" then
	       ret[#ret+1] = acc
	       acc = ""
	    end
	 else
	    acc = acc .. c
	    seen = false
	 end
      elseif seen == "{" then
	 if c == "}" then
	    seen = false
	    assert(acc:match(tagname_pattern), "Expected tag name in string expansion of ${...}")
	    ret[#ret+1] = { acc }
	    acc = ""
	 else
	    acc = acc .. c
	 end
      end
   end
   if seen == "$" then
      acc = acc .. seen
   elseif seen ~= false then
      error("Unterminated tag expansion in string.")
   end
   if acc ~= "" then
      ret[#ret+1] = acc
   end

   return ret
end

local function process_expansion(tags, expn, tagsactive)
   -- Expand expn with tags and return a single string
   if type(expn) == "string" then
      return expn
   end
   if not tagsactive then
      tagsactive = {}
   end
   local r = {}
   for i = 1, #expn do
      local elem = expn[i]
      if type(elem) == "string" then
	 r[#r+1] = elem
      else
	 elem = elem[1]
	 if tagsactive[elem] then
	    return do_deny(tags, "Loop detected in tag expansion")
	 end
	 local tag = tags[elem]
	 if type(tag) == "function" then
	    tags[elem] = tag(tags)
	    tag = tags[elem]
	 end
	 if type(tag) == "string" then
	    tagsactive[elem] = true
	    tag = process_expansion(tags, tag, tagsactive)
	    tagsactive[elem] = nil
	 else
	    -- Can't implicitly expand lists etc.
	    tag = ""
	 end
	 r[#r+1] = tag
      end
   end
   return tconcat(r)
end

local function set(t)
   local ret = {}
   for i, v in ipairs(t) do
      ret[i] = v
      ret[v] = i
   end
   return ret
end

local function add_splitable(context, key, value, splitter,
			     prefix_name, suffix_name)
   if not value or value == "" then
      return
   end
   local function _(k, v)
      context[k] = v
   end
   _(key, value)
   local prefix, suffix = value:match("^(.*%" .. splitter .. ")" ..
				      "([^%" .. splitter .. "]+)$")

   if prefix then
      _(key .. "/" .. prefix_name, prefix:sub(1, -2))
      _(key .. "/" .. suffix_name, suffix)
   else
      _(key .. "/" .. suffix_name, value)
   end

   local i = 1
   for section in value:gmatch("([^%" .. splitter .. "]+)") do
      _(key .. "/" .. tostring(i), section)
      i = i + 1
   end
end

return {
   parse_cmdline = _parse_cmdline,

   patesc = patesc,

   path_components = path_components,
   dirname = dirname,
   basename = basename,

   mkdir_p = mkdir_p,
   rm_rf = rm_rf,

   html_escape = html_escape,

   deep_copy = _deep_copy,

   prep_expansion = prep_expansion,

   add_splitable = add_splitable,
   process_expansion = process_expansion,

   set = set,
}