]> git.madduck.net Git - etc/awesome.git/blob - helpers.lua

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

309162e7a3d8e098043a395417f9ad296c439fee
[etc/awesome.git] / 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   local lines = {}
53   for line in io.lines(file) do
54     lines[#lines + 1] = line
55   end
56   return lines
57 end
58
59 -- match all lines from a file, returns an empty
60 -- list/table if the file or match does not exist
61 function helpers.lines_match(regexp, file)
62         local lines = {}
63         for index,line in pairs(helpers.lines_from(file)) do
64                 if string.match(line, regexp) then 
65                         lines[index] = line
66                 end  
67         end
68         return lines
69 end
70
71 -- get first line of a file, return nil if
72 -- the file does not exist
73 function helpers.first_line(file)
74     return helpers.lines_from(file)[1]
75 end
76
77 -- get first non empty line from a file,
78 -- returns nil otherwise
79 function helpers.first_nonempty_line(file)
80   for k,v in pairs(helpers.lines_from(file)) do
81     if #v then return v end
82   end
83   return nil
84 end
85
86 -- }}}
87
88 -- {{{ Timer maker
89
90 helpers.timer_table = {}
91
92 function helpers.newtimer(_name, timeout, fun, nostart)
93     local name = timeout
94     if not helpers.timer_table[name] then
95         helpers.timer_table[name] = capi.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 end
103
104 -- }}}
105
106 -- {{{ Pipe operations
107
108 -- read the full output of a pipe (command)
109 function helpers.read_pipe(cmd)
110    local f = assert(io.popen(cmd))
111    local output = f:read("*all")
112    f:close()
113    return output
114 end
115
116 -- }}}
117
118 -- {{{ A map utility
119
120 helpers.map_table = {}
121
122 function helpers.set_map(element, value)
123     helpers.map_table[element] = value
124 end
125
126 function helpers.get_map(element)
127     return helpers.map_table[element]
128 end
129
130 -- }}}
131
132 --{{{ Iterate over table of records sorted by keys
133 function helpers.spairs(t)
134     -- collect the keys
135     local keys = {}
136     for k in pairs(t) do keys[#keys+1] = k end
137
138     table.sort(keys)
139
140     -- return the iterator function
141     local i = 0
142     return function()
143         i = i + 1
144         if keys[i] then
145             return keys[i], t[keys[i]]
146         end
147     end
148 end
149 --}}}
150
151 return helpers