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

net: specify ip path; #102
[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 pipe (command)
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 -- }}}
118
119 -- {{{ A map utility
120
121 helpers.map_table = {}
122
123 function helpers.set_map(element, value)
124     helpers.map_table[element] = value
125 end
126
127 function helpers.get_map(element)
128     return helpers.map_table[element]
129 end
130
131 -- }}}
132
133 --{{{ Iterate over table of records sorted by keys
134 function helpers.spairs(t)
135     -- collect the keys
136     local keys = {}
137     for k in pairs(t) do keys[#keys+1] = k end
138
139     table.sort(keys)
140
141     -- return the iterator function
142     local i = 0
143     return function()
144         i = i + 1
145         if keys[i] then
146             return keys[i], t[keys[i]]
147         end
148     end
149 end
150 --}}}
151
152 return helpers