helpers.lua

   1 --[[
   2
   3      Licensed under GNU General Public License v2
   4       * (c) 2013, Luca CPZ
   5
   6 --]]
   7
   8 local spawn      = require("awful.spawn")
   9 local timer      = require("gears.timer")
  10 local debug      = require("debug")
  11 local io         = { lines = io.lines,
  12                      open  = io.open }
  13 local pairs      = pairs
  14 local rawget     = rawget
  15 local table      = { sort  = table.sort }
  16
  17 -- Lain helper functions for internal use
  18 -- lain.helpers
  19 local helpers = {}
  20
  21 helpers.lain_dir    = debug.getinfo(1, 'S').source:match[[^@(.*/).*$]]
  22 helpers.icons_dir   = helpers.lain_dir .. 'icons/'
  23 helpers.scripts_dir = helpers.lain_dir .. 'scripts/'
  24
  25 -- {{{ Modules loader
  26
  27 function helpers.wrequire(table, key)
  28     local module = rawget(table, key)
  29     return module or require(table._NAME .. '.' .. key)
  30 end
  31
  32 -- }}}
  33
  34 -- {{{ File operations
  35
  36 -- see if the file exists and is readable
  37 function helpers.file_exists(file)
  38   local f = io.open(file)
  39   if f then
  40       local s = f:read()
  41       f:close()
  42       f = s
  43   end
  44   return f ~= nil
  45 end
  46
  47 -- get all lines from a file, returns an empty
  48 -- list/table if the file does not exist
  49 function helpers.lines_from(file)
  50   if not helpers.file_exists(file) then return {} end
  51   local lines = {}
  52   for line in io.lines(file) do
  53     lines[#lines + 1] = line
  54   end
  55   return lines
  56 end
  57
  58 -- match all lines from a file, returns an empty
  59 -- list/table if the file or match does not exist
  60 function helpers.lines_match(regexp, file)
  61         local lines = {}
  62         for index,line in pairs(helpers.lines_from(file)) do
  63                 if string.match(line, regexp) then
  64                         lines[index] = line
  65                 end
  66         end
  67         return lines
  68 end
  69
  70 -- get first line of a file, return nil if
  71 -- the file does not exist
  72 function helpers.first_line(file)
  73     return helpers.lines_from(file)[1]
  74 end
  75
  76 -- get first non empty line from a file,
  77 -- returns nil otherwise
  78 function helpers.first_nonempty_line(file)
  79   for k,v in pairs(helpers.lines_from(file)) do
  80     if #v then return v end
  81   end
  82   return nil
  83 end
  84
  85 -- }}}
  86
  87 -- {{{ Timer maker
  88
  89 helpers.timer_table = {}
  90
  91 function helpers.newtimer(name, timeout, fun, nostart, stoppable)
  92     if not name or #name == 0 then return end
  93     name = (stoppable and name) or timeout
  94     if not helpers.timer_table[name] then
  95         helpers.timer_table[name] = timer({ timeout = timeout })
  96         helpers.timer_table[name]:start()
  97     end
  98     helpers.timer_table[name]:connect_signal("timeout", fun)
  99     if not nostart then
 100         helpers.timer_table[name]:emit_signal("timeout")
 101     end
 102     return stoppable and helpers.timer_table[name]
 103 end
 104
 105 -- }}}
 106
 107 -- {{{ Pipe operations
 108
 109 -- run a command and execute a function on its output (asynchronous pipe)
 110 -- @param cmd the input command
 111 -- @param callback function to execute on cmd output
 112 -- @return cmd PID
 113 function helpers.async(cmd, callback)
 114     return spawn.easy_async(cmd,
 115     function (stdout, stderr, reason, exit_code)
 116         callback(stdout, exit_code)
 117     end)
 118 end
 119
 120 -- like above, but call spawn.easy_async with a shell
 121 function helpers.async_with_shell(cmd, callback)
 122     return spawn.easy_async_with_shell(cmd,
 123     function (stdout, stderr, reason, exit_code)
 124         callback(stdout, exit_code)
 125     end)
 126 end
 127
 128 -- run a command and execute a function on its output line by line
 129 function helpers.line_callback(cmd, callback)
 130     return spawn.with_line_callback(cmd, {
 131         stdout = function (line)
 132             callback(line)
 133         end,
 134     })
 135 end
 136
 137 -- }}}
 138
 139 -- {{{ A map utility
 140
 141 helpers.map_table = {}
 142
 143 function helpers.set_map(element, value)
 144     helpers.map_table[element] = value
 145 end
 146
 147 function helpers.get_map(element)
 148     return helpers.map_table[element]
 149 end
 150
 151 -- }}}
 152
 153 -- {{{ Misc
 154
 155 -- check if an element exist on a table
 156 function helpers.element_in_table(element, tbl)
 157     for _, i in pairs(tbl) do
 158         if i == element then
 159             return true
 160         end
 161     end
 162     return false
 163 end
 164
 165 -- iterate over table of records sorted by keys
 166 function helpers.spairs(t)
 167     -- collect the keys
 168     local keys = {}
 169     for k in pairs(t) do keys[#keys+1] = k end
 170
 171     table.sort(keys)
 172
 173     -- return the iterator function
 174     local i = 0
 175     return function()
 176         i = i + 1
 177         if keys[i] then
 178             return keys[i], t[keys[i]]
 179         end
 180     end
 181 end
 182
 183 -- create the partition of singletons of a given set
 184 -- example: the trivial partition set of {a, b, c}, is {{a}, {b}, {c}}
 185 function helpers.trivial_partition_set(set)
 186     local ss = {}
 187     for _,e in pairs(set) do
 188         ss[#ss+1] = {e}
 189     end
 190     return ss
 191 end
 192
 193 -- creates the powerset of a given set
 194 function helpers.powerset(s)
 195     if not s then return {} end
 196     local t = {{}}
 197     for i = 1, #s do
 198         for j = 1, #t do
 199             t[#t+1] = {s[i],unpack(t[j])}
 200         end
 201     end
 202     return t
 203 end
 204
 205 -- }}}
 206
 207 return helpers