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