]> 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:

util.menu_iterator: cleaned indentation; added wiki entry; closes #386
[etc/awesome.git] / 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