helpers.lua

   1
   2 --[[
   3
   4      Licensed under GNU General Public License v2
   5       * (c) 2013, Luke Bonham
   6
   7 --]]
   8
   9 local debug  = require("debug")
  10
  11 local capi   = { timer = (type(timer) == 'table' and timer or require ("gears.timer")) }
  12 local io     = { open  = io.open,
  13                  lines = io.lines,
  14                  popen = io.popen }
  15 local rawget = rawget
  16 local table  = { sort   = table.sort }
  17
  18 -- Lain helper functions for internal use
  19 -- lain.helpers
  20 local helpers = {}
  21
  22 helpers.lain_dir    = debug.getinfo(1, 'S').source:match[[^@(.*/).*$]]
  23 helpers.icons_dir   = helpers.lain_dir .. 'icons/'
  24 helpers.scripts_dir = helpers.lain_dir .. 'scripts/'
  25
  26 -- {{{ Modules loader
  27
  28 function helpers.wrequire(table, key)
  29     local module = rawget(table, key)
  30     return module or require(table._NAME .. '.' .. key)
  31 end
  32
  33 -- }}}
  34
  35 -- {{{ File operations
  36
  37 -- see if the file exists and is readable
  38 function helpers.file_exists(file)
  39   local f = io.open(file)
  40   if f then
  41       local s = f:read()
  42       f:close()
  43       f = s
  44   end
  45   return f ~= nil
  46 end
  47
  48 -- get all lines from a file, returns an empty
  49 -- list/table if the file does not exist
  50 function helpers.lines_from(file)
  51   if not helpers.file_exists(file) then return {} end
  52   lines = {}
  53   for line in io.lines(file) do
  54     lines[#lines + 1] = line
  55   end
  56   return lines
  57 end
  58
  59 -- get first line of a file, return nil if
  60 -- the file does not exist
  61 function helpers.first_line(file)
  62     return helpers.lines_from(file)[1]
  63 end
  64
  65 -- get first non empty line from a file,
  66 -- returns nil otherwise
  67 function helpers.first_nonempty_line(file)
  68   for k,v in pairs(helpers.lines_from(file)) do
  69     if #v then return v end
  70   end
  71   return nil
  72 end
  73
  74 -- }}}
  75
  76 -- {{{ Timer maker
  77
  78 helpers.timer_table = {}
  79
  80 function helpers.newtimer(_name, timeout, fun, nostart)
  81     local name = timeout
  82     if not helpers.timer_table[name] then
  83         helpers.timer_table[name] = capi.timer({ timeout = timeout })
  84     end
  85     helpers.timer_table[name]:connect_signal("timeout", fun)
  86     helpers.timer_table[name]:start()
  87     if not nostart then
  88         helpers.timer_table[name]:emit_signal("timeout")
  89     end
  90 end
  91
  92 -- }}}
  93
  94 -- {{{ Pipe operations
  95
  96 -- read the full output of a pipe (command)
  97 function helpers.read_pipe(cmd)
  98    local f = assert(io.popen(cmd))
  99    local output = f:read("*all")
 100    f:close()
 101    return output
 102 end
 103
 104 -- }}}
 105
 106 -- {{{ A map utility
 107
 108 helpers.map_table = {}
 109
 110 function helpers.set_map(element, value)
 111     helpers.map_table[element] = value
 112 end
 113
 114 function helpers.get_map(element)
 115     return helpers.map_table[element]
 116 end
 117
 118 -- }}}
 119
 120 --{{{ Iterate over table of records sorted by keys
 121 function helpers.spairs(t)
 122     -- collect the keys
 123     local keys = {}
 124     for k in pairs(t) do keys[#keys+1] = k end
 125
 126     table.sort(keys)
 127
 128     -- return the iterator function
 129     local i = 0
 130     return function()
 131         i = i + 1
 132         if keys[i] then
 133             return keys[i], t[keys[i]]
 134         end
 135     end
 136 end
 137 --}}}
 138
 139 return helpers