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

wiki updated
[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 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