diff options
Diffstat (limited to 'libs/uvl/luasrc/uvl.lua')
| -rw-r--r-- | libs/uvl/luasrc/uvl.lua | 1213 |
1 files changed, 0 insertions, 1213 deletions
diff --git a/libs/uvl/luasrc/uvl.lua b/libs/uvl/luasrc/uvl.lua deleted file mode 100644 index d2ea4bd2c2..0000000000 --- a/libs/uvl/luasrc/uvl.lua +++ /dev/null @@ -1,1213 +0,0 @@ ---[[ - -UCI Validation Layer - Main Library -(c) 2008 Jo-Philipp Wich <xm@leipzig.freifunk.net> -(c) 2008 Steven Barth <steven@midlink.org> - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -$Id$ - -]]-- - - ---- UVL - UCI Validation Layer --- @class module --- @cstyle instance - -local fs = require "nixio.fs" -local uci = require "luci.model.uci" -local util = require "luci.util" -local nutil = require "nixio.util" -local table = require "table" -local string = require "string" - -local require, pcall, ipairs, pairs = require, pcall, ipairs, pairs -local type, error, tonumber, tostring = type, error, tonumber, tostring -local unpack, loadfile, collectgarbage = unpack, loadfile, collectgarbage - -module "luci.uvl" - -local ERR = require "luci.uvl.errors".error -local datatypes = require "luci.uvl.datatypes" -local validation = require "luci.uvl.validation" -local dependencies = require "luci.uvl.dependencies" - -local TYPE_SCHEME = 0x00 -local TYPE_CONFIG = 0x01 -local TYPE_SECTION = 0x02 -local TYPE_OPTION = 0x03 -local TYPE_ENUM = 0x04 - -local PAT_EXPR1 = "^%$?[%w_]+$" -local PAT_EXPR2 = "^%$?[%w_]+%.%$?[%w_]+$" -local PAT_EXPR3 = "^%$?[%w_]+%.%$?[%w_]+%.%$?[%w_]+$" - ---- Boolean; default true; --- treat sections found in config but not in scheme as error -STRICT_UNKNOWN_SECTIONS = true - ---- Boolean; default true; --- treat options found in config but not in scheme as error -STRICT_UNKNOWN_OPTIONS = true - ---- Boolean; default true; --- treat failed external validators as error -STRICT_EXTERNAL_VALIDATORS = true - ---- Boolean; default true; --- treat list values stored as options like errors -STRICT_LIST_TYPE = true - - -local default_schemedir = "/lib/uci/schema" -local default_savedir = "/tmp/.uvl" - - ---- Object constructor --- @class function --- @name UVL --- @param schemedir Path to the scheme directory (optional) --- @param configdir Override config directory (optional) --- @return Instance object -UVL = util.class() - -function UVL.__init__( self, schemedir, configdir ) - self.schemedir = schemedir or default_schemedir - self.configdir = configdir - self.packages = { } - self.beenthere = { } - self.depseen = { } - self.uci = uci - self.err = ERR - self.dep = dependencies - self.datatypes = datatypes -end - - ---- Parse given scheme and return the scheme tree. --- @param scheme Name of the scheme to parse --- @return Table containing the parsed scheme or nil on error --- @return String containing the reason for errors (if any) -function UVL.get_scheme( self, scheme ) - if not self.packages[scheme] then - local ok, err = self:read_scheme( scheme ) - if not ok then - return nil, err - end - end - return self.packages[scheme], nil -end - ---- Validate given configuration, section or option. --- @param config Name of the configuration to validate --- @param section Name of the section to validate (optional) --- @param option Name of the option to validate (optional) --- @return Boolean indicating whether the given config validates --- @return String containing the reason for errors (if any) -function UVL.validate( self, config, section, option ) - if config and section and option then - return self:validate_option( config, section, option ) - elseif config and section then - return self:validate_section( config, section ) - elseif config then - return self:validate_config( config ) - end -end - ---- Validate given configuration. --- @param cfg Name of the configuration to validate --- @return Boolean indicating whether the given config validates --- @return String containing the reason for errors (if any) -function UVL.validate_config( self, cfg, uci ) - - if not self.packages[cfg] then - local ok, err = self:read_scheme(cfg) - if not ok then - return false, err - end - end - - local co = config( self, uci or cfg, uci and cfg ) - local sc = { } - - self.beenthere = { } - self.depseen = { } - - if not co:config() then - return false, co:errors() - end - - local function _uci_foreach( type, func ) - for k, v in pairs(co:config()) do - if v['.type'] == type then - sc[type] = sc[type] + 1 - local ok, err = func( k, v ) - if not ok then co:error(err) end - end - end - end - - for k, v in pairs( self.packages[cfg].sections ) do - sc[k] = 0 - _uci_foreach( k, - function(s) - return self:_validate_section( co:section(s) ) - end - ) - end - - if STRICT_UNKNOWN_SECTIONS then - for k, v in pairs(co:config()) do - local so = co:section(k) - if not self.beenthere[so:cid()] then - co:error(ERR('SECT_UNKNOWN', so)) - end - end - end - - for _, k in ipairs(util.keys(sc)) do - local so = co:section(k) - if so:scheme('required') and sc[k] == 0 then - co:error(ERR('SECT_REQUIRED', so)) - elseif so:scheme('unique') and sc[k] > 1 then - co:error(ERR('SECT_UNIQUE', so)) - end - end - - return co:ok(), co:errors() -end - ---- Validate given config section. --- @param config Name of the configuration to validate --- @param section Name of the section to validate --- @return Boolean indicating whether the given config validates --- @return String containing the reason for errors (if any) -function UVL.validate_section( self, cfg, section, uci ) - - if not self.packages[cfg] then - local ok, err = self:read_scheme( cfg ) - if not ok then - return false, err - end - end - - local co = config( self, uci or cfg, uci and cfg ) - local so = co:section( section ) - - self.beenthere = { } - self.depseen = { } - - if not co:config() then - return false, co:errors() - end - - if so:config() then - return self:_validate_section( so ) - else - return false, ERR('SECT_NOTFOUND', so) - end -end - ---- Validate given config option. --- @param config Name of the configuration to validate --- @param section Name of the section to validate --- @param option Name of the option to validate --- @return Boolean indicating whether the given config validates --- @return String containing the reason for errors (if any) -function UVL.validate_option( self, cfg, section, option, uci ) - - if not self.packages[cfg] then - local ok, err = self:read_scheme( cfg ) - if not ok then - return false, err - end - end - - local co = config( self, uci or cfg, uci and cfg ) - local so = co:section( section ) - local oo = so:option( option ) - - if not co:config() then - return false, co:errors() - end - - if so:config() and oo:config() then - return self:_validate_option( oo ) - else - return false, ERR('OPT_NOTFOUND', oo) - end -end - - -function UVL._validate_section( self, section ) - - self.beenthere[section:cid()] = true - - if section:config() then - if section:scheme('named') == true and - section:config('.anonymous') == true - then - return false, ERR('SECT_NAMED', section) - end - - for _, v in ipairs(section:variables()) do - local ok, err = self:_validate_option( v ) - if not ok and ( - v:scheme('required') or v:scheme('type') == "enum" or ( - not err:is('DEP_NOTEQUAL') and - not err:is('DEP_NOVALUE') - ) - ) then - section:error(err) - end - end - - local ok, err = dependencies.check( self, section ) - if not ok then - section:error(err) - end - else - return false, ERR('SECT_NOTFOUND', section) - end - - if STRICT_UNKNOWN_OPTIONS and not section:scheme('dynamic') then - for k, v in pairs(section:config()) do - local oo = section:option(k) - if k:byte(1) == 46 and not self.beenthere[oo:cid()] then - section:error(ERR('OPT_UNKNOWN', oo)) - end - end - end - - return section:ok(), section:errors() -end - -function UVL._validate_option( self, option, nodeps ) - - self.beenthere[option:cid()] = true - - if not option:scheme() and not option:parent():scheme('dynamic') then - if STRICT_UNKNOWN_OPTIONS then - return false, option:error(ERR('OPT_UNKNOWN', option)) - else - return true - end - - elseif option:scheme() then - if not nodeps then - local ok, err = dependencies.check( self, option ) - if not ok then - if not err:is_all( - 'OPT_REQUIRED', - 'DEP_NOTEQUAL', - 'DEP_NOVALUE' - ) then - option:error(err) - return false, option:errors() - else - return true - end - end - end - - if option:scheme('required') and not option:value() then - return false, option:error(ERR('OPT_REQUIRED', option)) - - elseif option:value() then - local val = option:value() - - if option:scheme('type') == "reference" or - option:scheme('type') == "enum" - then - local scheme_values = option:scheme('values') or { } - local config_values = ( type(val) == "table" and val or { val } ) - for _, v in ipairs(config_values) do - if not scheme_values[v] then - return false, option:error( ERR( - 'OPT_BADVALUE', - option, { v, util.serialize_data( - util.keys(scheme_values) - ) } - ) ) - end - end - elseif option:scheme('type') == "list" then - if type(val) ~= "table" and STRICT_LIST_TYPE then - return false, option:error(ERR('OPT_NOTLIST', option)) - end - end - - if option:scheme('datatype') then - local dt = option:scheme('datatype') - - if self.datatypes[dt] then - val = ( type(val) == "table" and val or { val } ) - for i, v in ipairs(val) do - if not self.datatypes[dt]( v ) then - return false, option:error( - ERR('OPT_INVVALUE', option, { v, dt }) - ) - end - end - else - return false, option:error(ERR('OPT_DATATYPE', option, dt)) - end - end - - val = ( type(val) == "table" and val or { val } ) - for _, v in ipairs(val) do - if option:scheme('minlength') then - if #v < option:scheme('minlength') then - return false, option:error(ERR('OPT_RANGE', option)) - end - end - - if option:scheme('maxlength') then - if #v > option:scheme('maxlength') then - return false, option:error(ERR('OPT_RANGE', option)) - end - end - - local w = tonumber(v) - - if option:scheme('minimum') then - if not w or w < option:scheme('minimum') then - return false, option:error(ERR('OPT_RANGE', option)) - end - end - - if option:scheme('maximum') then - if not w or w > option:scheme('maximum') then - return false, option:error(ERR('OPT_RANGE', option)) - end - end - end - end - - local ok, err = validation.check( self, option ) - if not ok and STRICT_EXTERNAL_VALIDATORS then - return false, option:error(err) - end - end - - return option:ok(), option:errors() -end - ---- Find all parts of given scheme and construct validation tree. --- This is normally done on demand, so you don't have to call this function --- by yourself. --- @param shm Name of the scheme to parse --- @param alias Create an alias for the loaded scheme -function UVL.read_scheme( self, shm, alias ) - - local so = scheme( self, shm ) - local bc = "%s/bytecode/%s.lua" %{ self.schemedir, shm } - - if not fs.access(bc) then - local files = nutil.consume((fs.glob(self.schemedir .. '/*/' .. shm))) - - if #files > 0 then - local ok, err - for _, file in ipairs(files) do - if not fs.access(file) then - return false, so:error(ERR('SME_READ', so,file)) - end - - local uci = uci.cursor( fs.dirname(file), default_savedir ) - - local sname = fs.basename(file) - local sd, err = uci:load( sname ) - - if not sd then - return false, ERR('UCILOAD', so, err) - end - - ok, err = pcall(function() - uci:foreach(sname, "package", function(s) - self:_parse_package(so, s[".name"], s) - end) - uci:foreach(sname, "section", function(s) - self:_parse_section(so, s[".name"], s) - end) - uci:foreach(sname, "variable", function(s) - self:_parse_var(so, s[".name"], s) - end) - uci:foreach(sname, "enum", function(s) - self:_parse_enum(so, s[".name"], s) - end) - - end) - end - - if ok and alias then self.packages[alias] = self.packages[shm] end - return ok and self, err - else - return false, so:error(ERR('SME_FIND', so, self.schemedir)) - end - else - local sc = loadfile(bc) - if sc then - self.packages[shm] = sc() - return true - else - return false, so:error(ERR('SME_READ',so,bc)) - end - end -end - --- helper function to check for required fields -local function _req( t, n, c, r ) - for i, v in ipairs(r) do - if not c[v] then - local p, o = scheme:sid(), nil - - if t == TYPE_SECTION then - o = section( scheme, nil, p, n ) - elseif t == TYPE_OPTION then - o = option( scheme, nil, p, '(nil)', n ) - elseif t == TYPE_ENUM then - o = enum( scheme, nil, p, '(nil)', '(nil)', n ) - end - - return false, ERR('SME_REQFLD',o,v) - end - end - return true -end - --- helper function to validate references -local function _ref( c, t ) - local r, k, n = {} - if c == TYPE_SECTION then - k = "package" - n = 1 - elseif c == TYPE_OPTION then - k = "section" - n = 2 - elseif c == TYPE_ENUM then - k = "variable" - n = 3 - end - - for o in t[k]:gmatch("[^.]+") do - r[#r+1] = o - end - r[1] = ( #r[1] > 0 and r[1] or scheme:sid() ) - - if #r ~= n then - return false, ERR('SME_BADREF', scheme, k) - end - - return r -end - --- helper function to read bools -local function _bool( v ) - return ( v == "true" or v == "yes" or v == "on" or v == "1" ) -end - --- Step 0: get package meta information -function UVL._parse_package(self, scheme, k, v) - local sid = scheme:sid() - local pkg = self.packages[sid] or { - ["name"] = sid; - ["sections"] = { }; - ["variables"] = { }; - } - - pkg.title = v.title - pkg.description = v.description - - self.packages[sid] = pkg -end - --- Step 1: get all sections -function UVL._parse_section(self, scheme, k, v) - local ok, err = _req( TYPE_SECTION, k, v, { "name", "package" } ) - if err then error(scheme:error(err)) end - - local r, err = _ref( TYPE_SECTION, v ) - if err then error(scheme:error(err)) end - - local p = self.packages[r[1]] or { - ["name"] = r[1]; - ["sections"] = { }; - ["variables"] = { }; - } - p.sections[v.name] = p.sections[v.name] or { } - p.variables[v.name] = p.variables[v.name] or { } - self.packages[r[1]] = p - - local s = p.sections[v.name] - local so = scheme:section(v.name) - - for k, v2 in pairs(v) do - if k ~= "name" and k ~= "package" and k:byte(1) == 46 then - if k == "depends" then - s.depends = self:_read_dependency( v2, s.depends ) - if not s.depends then - return false, scheme:error( - ERR('SME_BADDEP', so, util.serialize_data(s.depends)) - ) - end - elseif k == "dynamic" or k == "unique" or - k == "required" or k == "named" - then - s[k] = _bool(v2) - else - s[k] = v2 - end - end - end - - s.dynamic = s.dynamic or false - s.unique = s.unique or false - s.required = s.required or false - s.named = s.named or false -end - --- Step 2: get all variables -function UVL._parse_var(self, scheme, k, v) - local ok, err = _req( TYPE_OPTION, k, v, { "name", "section" } ) - if err then error(scheme:error(err)) end - - local r, err = _ref( TYPE_OPTION, v ) - if err then error(scheme:error(err)) end - - local p = self.packages[r[1]] - if not p then - error(scheme:error( - ERR('SME_VBADPACK', {scheme:sid(), '', v.name}, r[1]) - )) - end - - local s = p.variables[r[2]] - if not s then - error(scheme:error( - ERR('SME_VBADSECT', {scheme:sid(), '', v.name}, r[2]) - )) - end - - s[v.name] = s[v.name] or { } - - local t = s[v.name] - local so = scheme:section(r[2]) - local to = so:option(v.name) - - for k, v2 in pairs(v) do - if k ~= "name" and k ~= "section" and k:byte(1) == 46 then - if k == "depends" then - t.depends = self:_read_dependency( v2, t.depends ) - if not t.depends then - error(scheme:error(so:error( - ERR('SME_BADDEP', to, util.serialize_data(v2)) - ))) - end - elseif k == "validator" then - t.validators = self:_read_validator( v2, t.validators ) - if not t.validators then - error(scheme:error(so:error( - ERR('SME_BADVAL', to, util.serialize_data(v2)) - ))) - end - elseif k == "valueof" then - local values, err = self:_read_reference( v2 ) - if err then - error(scheme:error(so:error( - ERR('REFERENCE', to, util.serialize_data(v2)):child(err) - ))) - end - t.type = "reference" - t.values = values - t.valueof = type(v2) == "table" and v2 or {v2} - elseif k == "required" then - t[k] = _bool(v2) - elseif k == "minlength" or k == "maxlength" or - k == "minimum" or k == "maximum" - then - t[k] = tonumber(v2) - else - t[k] = t[k] or v2 - end - end - end - - t.type = t.type or "variable" - t.datatype = t.datatype or "string" - t.required = t.required or false -end - --- Step 3: get all enums -function UVL._parse_enum(self, scheme, k, v) - local ok, err = _req( TYPE_ENUM, k, v, { "value", "variable" } ) - if err then error(scheme:error(err)) end - - local r, err = _ref( TYPE_ENUM, v ) - if err then error(scheme:error(err)) end - - local p = self.packages[r[1]] - if not p then - error(scheme:error( - ERR('SME_EBADPACK', {scheme:sid(), '', '', v.value}, r[1]) - )) - end - - local s = p.variables[r[2]] - if not s then - error(scheme:error( - ERR('SME_EBADSECT', {scheme:sid(), '', '', v.value}, r[2]) - )) - end - - local t = s[r[3]] - if not t then - error(scheme:error( - ERR('SME_EBADOPT', {scheme:sid(), '', '', v.value}, r[3]) - )) - end - - - local so = scheme:section(r[2]) - local oo = so:option(r[3]) - local eo = oo:enum(v.value) - - if t.type ~= "enum" and t.type ~= "reference" then - error(scheme:error(ERR('SME_EBADTYPE', eo))) - end - - if not t.values then - t.values = { [v.value] = v.title or v.value } - t.valuelist = { {value = v.value, title = v.title} } - else - t.values[v.value] = v.title or v.value - t.valuelist[#t.valuelist + 1] = {value = v.value, title = v.title} - end - - if not t.enum_depends then - t.enum_depends = { } - end - - if v.default then - if t.default then - error(scheme:error(ERR('SME_EBADDEF', eo))) - end - t.default = v.value - end - - if v.depends then - t.enum_depends[v.value] = self:_read_dependency( - v.depends, t.enum_depends[v.value] - ) - - if not t.enum_depends[v.value] then - error(scheme:error(so:error(oo:error( - ERR('SME_BADDEP', eo, util.serialize_data(v.depends)) - )))) - end - end -end - --- Read a dependency specification -function UVL._read_dependency( self, values, deps ) - local expr = "%$?[%w_]+" - if values then - values = ( type(values) == "table" and values or { values } ) - for _, value in ipairs(values) do - local condition = { } - for val in value:gmatch("[^,]+") do - local k, e, v = val:match("%s*([%w$_.]+)%s*(=?)%s*(.*)") - - if k and ( - k:match(PAT_EXPR1) or k:match(PAT_EXPR2) or k:match(PAT_EXPR3) - ) then - condition[k] = (e == '=') and v or true - else - return nil - end - end - - if not deps then - deps = { condition } - else - deps[#deps+1] = condition - end - end - end - - return deps -end - --- Read a validator specification -function UVL._read_validator( self, values, validators ) - if values then - values = ( type(values) == "table" and values or { values } ) - for _, value in ipairs(values) do - local validator - - if value:match("^exec:") then - validator = value:gsub("^exec:","") - elseif value:match("^lua:") then - validator = self:_resolve_function( (value:gsub("^lua:","") ) ) - elseif value:match("^regexp:") then - local pattern = value:gsub("^regexp:","") - validator = function( type, dtype, pack, sect, optn, arg1, arg2, arg3, arg4, arg5 ) - local values = { arg1, arg2, arg3, arg4, arg5 } - for _, v in ipairs(values) do - local ok, match = - pcall( string.match, v, pattern ) - - if not ok then - return false, match - elseif not match then - return false, - 'Value "%s" does not match pattern "%s"' % { - v, pattern - } - end - end - return true - end - end - - if validator then - if not validators then - validators = { validator } - else - validators[#validators+1] = validator - end - else - return nil - end - end - - return validators - end -end - --- Read a reference specification (XXX: We should validate external configs too...) -function UVL._read_reference( self, values ) - local val = { } - values = ( type(values) == "table" and values or { values } ) - - for _, value in ipairs(values) do - local ref = util.split(value, ".") - - if #ref == 2 or #ref == 3 then - local co = config( self, ref[1] ) - if not co:config() then return false, co:errors() end - - for k, v in pairs(co:config()) do - if v['.type'] == ref[2] then - if #ref == 2 then - if v['.anonymous'] == true then - return false, ERR('SME_INVREF', '', value) - end - val[k] = k -- XXX: title/description would be nice - elseif v[ref[3]] then - val[v[ref[3]]] = v[ref[3]] -- XXX: dito - end - end - end - else - return false, ERR('SME_BADREF', '', value) - end - end - - return val, nil -end - --- Resolve given path -function UVL._resolve_function( self, value ) - local path = util.split(value, ".") - - for i=1, #path-1 do - local stat, mod = pcall( - require, table.concat(path, ".", 1, i) - ) - - if stat and mod then - for j=i+1, #path-1 do - if not type(mod) == "table" then - break - end - mod = mod[path[j]] - if not mod then - break - end - end - mod = type(mod) == "table" and mod[path[#path]] or nil - if type(mod) == "function" then - return mod - end - end - end -end - - ---- Object representation of an uvl item - base class. -uvlitem = util.class() - -function uvlitem.cid(self) - if #self.cref == 1 then - return self.cref[1] - else - local r = { unpack(self.cref) } - local c = self.c - if c and c[r[2]] and c[r[2]]['.anonymous'] and c[r[2]]['.index'] then - r[2] = '@' .. c[r[2]]['.type'] .. - '[' .. tostring(c[r[2]]['.index']) .. ']' - end - return table.concat( r, '.' ) - end -end - -function uvlitem.sid(self) - return table.concat( self.sref, '.' ) -end - -function uvlitem.scheme(self, opt) - local s = self.s and self.s.packages - s = s and s[self.sref[1]] - if #self.sref == 4 or #self.sref == 3 then - s = s and s.variables - s = s and s[self.sref[2]] - s = s and s[self.sref[3]] - elseif #self.sref == 2 then - s = s and s.sections - s = s and s[self.sref[2]] - end - - if s and opt then - return s[opt] - elseif s then - return s - end -end - -function uvlitem.config(self, opt) - local c = self.c - - if #self.cref >= 2 and #self.cref <= 4 then - c = c and self.c[self.cref[2]] or nil - if #self.cref >= 3 then - c = c and c[self.cref[3]] or nil - end - end - - if c and opt then - return c[opt] - elseif c then - return c - end -end - -function uvlitem.title(self) - return self:scheme() and self:scheme('title') or - self.cref[3] or self.cref[2] or self.cref[1] -end - -function uvlitem.type(self) - if self.t == TYPE_CONFIG then - return 'config' - elseif self.t == TYPE_SECTION then - return 'section' - elseif self.t == TYPE_OPTION then - return 'option' - elseif self.t == TYPE_ENUM then - return 'enum' - end -end - -function uvlitem.error(self, arg1, arg2, arg3, arg4, arg5) - if not self.e then - local errconst = { 'CONFIG', 'SECTION', 'OPTION', 'OPTION' } - self.e = ERR( errconst[#self.cref], self ) - end - - return self.e:child( arg1, arg2, arg3, arg4, arg5 ) -end - -function uvlitem.errors(self) - return self.e -end - -function uvlitem.ok(self) - return not self:errors() -end - -function uvlitem.parent(self) - if self.p then - return self.p - elseif #self.cref == 3 or #self.cref == 4 then - return section( self.s, self.c, self.cref[1], self.cref[2] ) - elseif #self.cref == 2 then - return config( self.s, self.c, self.cref[1] ) - else - return nil - end -end - -function uvlitem._loadconf(self, co, c, configdir) - co = co or self._configcache - if not co then - local err - co, err = uci.cursor(configdir):get_all(c) - - if err then - self:error(ERR('UCILOAD', self, err)) - end - - self._configcache = co - end - return co -end - - ---- Object representation of a scheme. --- @class scheme --- @cstyle instance --- @name luci.uvl.scheme - ---- Scheme instance constructor. --- @class function --- @name scheme --- @param scheme Scheme instance --- @param co Configuration data --- @param c Configuration name --- @return Config instance -scheme = util.class(uvlitem) - -function scheme.__init__(self, scheme, co, c) - if not c then - c, co = co, nil - end - - self.cref = { c } - self.sref = { c } - self.c = self:_loadconf(co, c, scheme.configdir) - self.s = scheme - self.t = TYPE_SCHEME -end - ---- Add an error to scheme. --- @return Scheme error context -function scheme.error(self, arg1, arg2, arg3, arg4, arg5) - if not self.e then self.e = ERR( 'SCHEME', self ) end - return self.e:child( arg1, arg2, arg3, arg4, arg5 ) -end - ---- Get an associated config object. --- @return Config instance -function scheme.config(self) - local co = config( self.s, self.cref[1] ) - co.p = self - - return co -end - ---- Get all section objects associated with this scheme. --- @return Table containing all associated luci.uvl.section instances -function scheme.sections(self) - local v = { } - if self.s.packages[self.sref[1]].sections then - for o, _ in pairs( self.s.packages[self.sref[1]].sections ) do - v[#v+1] = option( - self.s, self.c, self.cref[1], self.cref[2], o - ) - end - end - return v -end - ---- Get an associated section object. --- @param s Section to select --- @return Section instance -function scheme.section(self, s) - local so = section( self.s, self.c, self.cref[1], s ) - so.p = self - - return so -end - - ---- Object representation of a config. --- @class config --- @cstyle instance --- @name luci.uvl.config - ---- Config instance constructor. --- @class function --- @name config --- @param scheme Scheme instance --- @param co Configuration data --- @param c Configuration name --- @return Config instance -config = util.class(uvlitem) - -function config.__init__(self, scheme, co, c) - if not c then - c, co = co, nil - end - self.cref = { c } - self.sref = { c } - self.c = self:_loadconf(co, c, scheme.configdir) - self.s = scheme - self.t = TYPE_CONFIG -end - ---- Get all section objects associated with this config. --- @return Table containing all associated luci.uvl.section instances -function config.sections(self) - local v = { } - if self.s.packages[self.sref[1]].sections then - for o, _ in pairs( self.s.packages[self.sref[1]].sections ) do - v[#v+1] = option( - self.s, self.c, self.cref[1], self.cref[2], o - ) - end - end - return v -end - ---- Get an associated section object. --- @param s Section to select --- @return Section instance -function config.section(self, s) - local so = section( self.s, self.c, self.cref[1], s ) - so.p = self - - return so -end - - ---- Object representation of a scheme/config section. --- @class module --- @cstyle instance --- @name luci.uvl.section - ---- Section instance constructor. --- @class function --- @name section --- @param scheme Scheme instance --- @param co Configuration data --- @param c Configuration name --- @param s Section name --- @return Section instance -section = util.class(uvlitem) - -function section.__init__(self, scheme, co, c, s) - self.cref = { c, s } - self.sref = { c, co and co[s] and co[s]['.type'] or s } - self.c = self:_loadconf(co, c, scheme.configdir) - self.s = scheme - self.t = TYPE_SECTION -end - ---- Get all option objects associated with this section. --- @return Table containing all associated luci.uvl.option instances -function section.variables(self) - local v = { } - if self.s.packages[self.sref[1]].variables[self.sref[2]] then - for o, _ in pairs( - self.s.packages[self.sref[1]].variables[self.sref[2]] - ) do - v[#v+1] = option( - self.s, self.c, self.cref[1], self.cref[2], o - ) - end - end - return v -end - ---- Get an associated option object. --- @param o Option to select --- @return Option instance -function section.option(self, o) - local oo = option( self.s, self.c, self.cref[1], self.cref[2], o ) - oo.p = self - - return oo -end - - ---- Object representation of a scheme/config option. --- @class module --- @cstyle instance --- @name luci.uvl.option - ---- Section instance constructor. --- @class function --- @name option --- @param scheme Scheme instance --- @param co Configuration data --- @param c Configuration name --- @param s Section name --- @param o Option name --- @return Option instance -option = util.class(uvlitem) - -function option.__init__(self, scheme, co, c, s, o) - self.cref = { c, s, o } - self.sref = { c, co and co[s] and co[s]['.type'] or s, o } - self.c = self:_loadconf(co, c, scheme.configdir) - self.s = scheme - self.t = TYPE_OPTION -end - ---- Get the value of this option. --- @return The associated configuration value -function option.value(self) - local v = self:config() or self:scheme('default') - if v and self:scheme('multival') then - v = util.split( v, "%s+", nil, true ) - end - return v -end - ---- Get the associated section information in scheme. --- @return Table containing the scheme properties -function option.section(self) - return self.s.packages[self.sref[1]].sections[self.sref[2]] -end - ---- Construct an enum object instance from given or default value. --- @param v Value to select --- @return Enum instance for selected value -function option.enum(self, val) - return enum( - self.s, self.c, - self.cref[1], self.cref[2], self.cref[3], - val or self:value() - ) -end - - ---- Object representation of a enum value. --- @class module --- @cstyle instance --- @name luci.uvl.enum - ---- Section instance constructor. --- @class function --- @name enum --- @param scheme Scheme instance --- @param co Configuration data --- @param c Configuration name --- @param s Section name --- @param o Enum name --- @param v Enum value --- @return Enum value instance -enum = util.class(option) - -function enum.__init__(self, scheme, co, c, s, o, v) - self.cref = { c, s, o, v } - self.sref = { c, co and co[s] and co[s]['.type'] or s, o, v } - self.c = self:_loadconf(co, c, scheme.configdir) - self.s = scheme - self.t = TYPE_ENUM -end |