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 -- check if the file exists and is readable
  37 function helpers.file_exists(path)
  38     local file = io.open(path, "rb")
  39     if file then file:close() end
  40     return file ~= nil
  41 end
  42
  43 -- get a table with all lines from a file
  44 function helpers.lines_from(path)
  45     local lines = {}
  46     for line in io.lines(path) do
  47         lines[#lines + 1] = line
  48     end
  49     return lines
  50 end
  51
  52 -- get a table with all lines from a file matching regexp
  53 function helpers.lines_match(regexp, path)
  54     local lines = {}
  55     for line in io.lines(path) do
  56         if string.match(line, regexp) then
  57             lines[#lines + 1] = line
  58         end
  59     end
  60     return lines
  61 end
  62
  63 -- get first line of a file
  64 function helpers.first_line(path)
  65     local file, first = io.open(path, "rb"), nil
  66     if file then
  67         first = file:read("*l")
  68         file:close()
  69     end
  70     return first
  71 end
  72
  73 -- get first non empty line from a file
  74 function helpers.first_nonempty_line(path)
  75     for line in io.lines(path) do
  76         if #line then return line end
  77     end
  78     return nil
  79 end
  80
  81 -- }}}
  82
  83 -- {{{ Timer maker
  84
  85 helpers.timer_table = {}
  86
  87 function helpers.newtimer(name, timeout, fun, nostart, stoppable)
  88     if not name or #name == 0 then return end
  89     name = (stoppable and name) or timeout
  90     if not helpers.timer_table[name] then
  91         helpers.timer_table[name] = timer({ timeout = timeout })
  92         helpers.timer_table[name]:start()
  93     end
  94     helpers.timer_table[name]:connect_signal("timeout", fun)
  95     if not nostart then
  96         helpers.timer_table[name]:emit_signal("timeout")
  97     end
  98     return stoppable and helpers.timer_table[name]
  99 end
 100
 101 -- }}}
 102
 103 -- {{{ Pipe operations
 104
 105 -- run a command and execute a function on its output (asynchronous pipe)
 106 -- @param cmd the input command
 107 -- @param callback function to execute on cmd output
 108 -- @return cmd PID
 109 function helpers.async(cmd, callback)
 110     return spawn.easy_async(cmd,
 111     function (stdout, stderr, reason, exit_code)
 112         callback(stdout, exit_code)
 113     end)
 114 end
 115
 116 -- like above, but call spawn.easy_async with a shell
 117 function helpers.async_with_shell(cmd, callback)
 118     return spawn.easy_async_with_shell(cmd,
 119     function (stdout, stderr, reason, exit_code)
 120         callback(stdout, exit_code)
 121     end)
 122 end
 123
 124 -- run a command and execute a function on its output line by line
 125 function helpers.line_callback(cmd, callback)
 126     return spawn.with_line_callback(cmd, {
 127         stdout = function (line)
 128             callback(line)
 129         end,
 130     })
 131 end
 132
 133 -- }}}
 134
 135 -- {{{ A map utility
 136
 137 helpers.map_table = {}
 138
 139 function helpers.set_map(element, value)
 140     helpers.map_table[element] = value
 141 end
 142
 143 function helpers.get_map(element)
 144     return helpers.map_table[element]
 145 end
 146
 147 -- }}}
 148
 149 -- {{{ Misc
 150
 151 -- check if an element exist on a table
 152 function helpers.element_in_table(element, tbl)
 153     for _, i in pairs(tbl) do
 154         if i == element then
 155             return true
 156         end
 157     end
 158     return false
 159 end
 160
 161 -- iterate over table of records sorted by keys
 162 function helpers.spairs(t)
 163     -- collect the keys
 164     local keys = {}
 165     for k in pairs(t) do keys[#keys+1] = k end
 166
 167     table.sort(keys)
 168
 169     -- return the iterator function
 170     local i = 0
 171     return function()
 172         i = i + 1
 173         if keys[i] then
 174             return keys[i], t[keys[i]]
 175         end
 176     end
 177 end
 178
 179 -- create the partition of singletons of a given set
 180 -- example: the trivial partition set of {a, b, c}, is {{a}, {b}, {c}}
 181 function helpers.trivial_partition_set(set)
 182     local ss = {}
 183     for _,e in pairs(set) do
 184         ss[#ss+1] = {e}
 185     end
 186     return ss
 187 end
 188
 189 -- creates the powerset of a given set
 190 function helpers.powerset(s)
 191     if not s then return {} end
 192     local t = {{}}
 193     for i = 1, #s do
 194         for j = 1, #t do
 195             t[#t+1] = {s[i],unpack(t[j])}
 196         end
 197     end
 198     return t
 199 end
 200
 201 -- }}}
 202
 203 return helpers