src/ffluci/util.lua

   1 --[[
   2 FFLuCI - Utility library
   3
   4 Description:
   5 Several common useful Lua functions
   6
   7 FileId:
   8 $Id$
   9
  10 License:
  11 Copyright 2008 Steven Barth <steven@midlink.org>
  12
  13 Licensed under the Apache License, Version 2.0 (the "License");
  14 you may not use this file except in compliance with the License.
  15 You may obtain a copy of the License at
  16
  17         http://www.apache.org/licenses/LICENSE-2.0
  18
  19 Unless required by applicable law or agreed to in writing, software
  20 distributed under the License is distributed on an "AS IS" BASIS,
  21 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  22 See the License for the specific language governing permissions and
  23 limitations under the License.
  24
  25 ]]--
  26
  27 module("ffluci.util", package.seeall)
  28
  29
  30 -- Lua simplified Python-style OO class support emulation
  31 function class(base)
  32         local class = {}
  33
  34         local create = function(class, ...)
  35                 local inst = {}
  36                 setmetatable(inst, {__index = class})
  37
  38                 if inst.__init__ then
  39                         local stat, err = pcall(inst.__init__, inst, ...)
  40                         if not stat then
  41                                 error(err)
  42                         end
  43                 end
  44
  45                 return inst
  46         end
  47
  48         local classmeta = {__call = create}
  49
  50         if base then
  51                 classmeta.__index = base
  52         end
  53
  54         setmetatable(class, classmeta)
  55         return class
  56 end
  57
  58
  59 -- Clones an object (deep on-demand)
  60 function clone(object, deep)
  61         local copy = {}
  62
  63         for k, v in pairs(object) do
  64                 if deep and type(v) == "table" then
  65                         v = clone(v, deep)
  66                 end
  67                 copy[k] = v
  68         end
  69
  70         setmetatable(copy, getmetatable(object))
  71
  72         return copy
  73 end
  74
  75
  76 -- Checks whether a table has an object "value" in it
  77 function contains(table, value)
  78         for k,v in pairs(table) do
  79                 if value == v then
  80                         return true
  81                 end
  82         end
  83         return false
  84 end
  85
  86
  87 -- Dumps a table to stdout (useful for testing and debugging)
  88 function dumptable(t, i)
  89         i = i or 0
  90         for k,v in pairs(t) do
  91                 print(string.rep("\t", i) .. k, v)
  92                 if type(v) == "table" then
  93                         dumptable(v, i+1)
  94                 end
  95         end
  96 end
  97
  98
  99 -- Escapes all occurences of c in s
 100 function escape(s, c)
 101         c = c or "\\"
 102         return s:gsub(c, "\\" .. c)
 103 end
 104
 105
 106 -- Runs "command" and returns its output
 107 function exec(command)
 108         local pp   = io.popen(command)
 109         local data = pp:read("*a")
 110         pp:close()
 111
 112         return data
 113 end
 114
 115
 116 -- Runs "command" and returns its output as a array of lines
 117 function execl(command)
 118         local pp   = io.popen(command)
 119         local line = ""
 120         local data = {}
 121
 122         while true do
 123                 line = pp:read()
 124                 if (line == nil) then break end
 125                 table.insert(data, line)
 126         end
 127         pp:close()
 128
 129         return data
 130 end
 131
 132
 133 -- Populate obj in the scope of f as key
 134 function extfenv(f, key, obj)
 135         local scope = getfenv(f)
 136         scope[key] = obj
 137 end
 138
 139
 140 -- Checks whether an object is an instanceof class
 141 function instanceof(object, class)
 142         local meta = getmetatable(object)
 143     while meta and meta.__index do
 144         if meta.__index == class then
 145                 return true
 146         end
 147         meta = getmetatable(meta.__index)
 148     end
 149     return false
 150 end
 151
 152
 153 -- Resets the scope of f doing a shallow copy of its scope into a new table
 154 function resfenv(f)
 155         setfenv(f, clone(getfenv(f)))
 156 end
 157
 158
 159 -- Returns the Haserl unique sessionid
 160 function sessionid()
 161         return ENV.SESSIONID
 162 end
 163
 164
 165 -- Splits a string into an array (Taken from lua-users.org)
 166 function split(str, pat)
 167         pat = pat or "\n"
 168
 169         local t = {}
 170         local fpat = "(.-)" .. pat
 171         local last_end = 1
 172         local s, e, cap = str:find(fpat, 1)
 173
 174         while s do
 175                 if s ~= 1 or cap ~= "" then
 176                         table.insert(t,cap)
 177                 end
 178                 last_end = e+1
 179                 s, e, cap = str:find(fpat, last_end)
 180         end
 181
 182         if last_end <= #str then
 183                 cap = str:sub(last_end)
 184                 table.insert(t, cap)
 185         end
 186
 187         return t
 188 end
 189
 190
 191 -- Updates given table with new values
 192 function update(t, updates)
 193         for k, v in pairs(updates) do
 194                 t[k] = v
 195         end
 196 end
 197
 198
 199 -- Updates the scope of f with "extscope"
 200 function updfenv(f, extscope)
 201         update(getfenv(f), extscope)
 202 end
 203
 204
 205 -- Validates a variable
 206 function validate(value, cast_number, cast_int)
 207         if cast_number or cast_int then
 208                 value = tonumber(value)
 209         end
 210
 211         if cast_int and value and not(value % 1 == 0) then
 212                 value = nil
 213         end
 214
 215         return value
 216 end
 217
 218
 219 -- Returns the filename of the calling script
 220 function __file__()
 221         return debug.getinfo(2, 'S').source:sub(2)
 222 end