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

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