path: root/libs/cbi/luasrc/cbi.lua

--[[
LuCI - Configuration Bind Interface

Description:
Offers an interface for binding configuration values to certain
data types. Supports value and range validation and basic dependencies.

FileId:
$Id$

License:
Copyright 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

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

]]--
module("luci.cbi", package.seeall)

require("luci.template")
require("luci.util")
require("luci.http")
require("luci.uvl")

local uci        = require("luci.model.uci")
local class      = luci.util.class
local instanceof = luci.util.instanceof

FORM_NODATA  =  0
FORM_VALID   =  1
FORM_INVALID = -1

AUTO = true

CREATE_PREFIX = "cbi.cts."
REMOVE_PREFIX = "cbi.rts."

-- Loads a CBI map from given file, creating an environment and returns it
function load(cbimap, ...)
	require("luci.fs")
	require("luci.i18n")
	require("luci.config")
	require("luci.util")

	local cbidir = luci.util.libpath() .. "/model/cbi/"
	local func, err = loadfile(cbidir..cbimap..".lua")

	if not func then
		return nil
	end

	luci.i18n.loadc("cbi")

	luci.util.resfenv(func)
	luci.util.updfenv(func, luci.cbi)
	luci.util.extfenv(func, "translate", luci.i18n.translate)
	luci.util.extfenv(func, "translatef", luci.i18n.translatef)
	luci.util.extfenv(func, "arg", {...})

	local maps = {func()}

	for i, map in ipairs(maps) do
		if not instanceof(map, Node) then
			error("CBI map returns no valid map object!")
			return nil
		end
	end

	return maps
end


function _uvl_strip_remote_dependencies(deps)
	local clean = {}

	for k, v in pairs(deps) do
		k = k:gsub("%$config%.%$section%.", "")
		if k:match("^[%w_]+$") and type(v) == "string" then
			clean[k] = v
		end
	end

	return clean
end


-- Node pseudo abstract class
Node = class()

function Node.__init__(self, title, description)
	self.children = {}
	self.title = title or ""
	self.description = description or ""
	self.template = "cbi/node"
end

-- i18n helper
function Node._i18n(self, config, section, option, title, description)

	-- i18n loaded?
	if type(luci.i18n) == "table" then

		local key = config and config:gsub("[^%w]+", "") or ""

		if section then	key = key .. "_" .. section:lower():gsub("[^%w]+", "") end
		if option  then key = key .. "_" .. tostring(option):lower():gsub("[^%w]+", "")  end

		self.title = title or luci.i18n.translate( key, option or section or config )
		self.description = description or luci.i18n.translate( key .. "_desc", "" )
	end
end

-- Append child nodes
function Node.append(self, obj)
	table.insert(self.children, obj)
end

-- Parse this node and its children
function Node.parse(self, ...)
	for k, child in ipairs(self.children) do
		child:parse(...)
	end
end

-- Render this node
function Node.render(self, scope)
	scope = scope or {}
	scope.self = self

	luci.template.render(self.template, scope)
end

-- Render the children
function Node.render_children(self, ...)
	for k, node in ipairs(self.children) do
		node:render(...)
	end
end


--[[
A simple template element
]]--
Template = class(Node)

function Template.__init__(self, template)
	Node.__init__(self)
	self.template = template
end

function Template.render(self)
	luci.template.render(self.template, {self=self})
end


--[[
Map - A map describing a configuration file
]]--
Map = class(Node)

function Map.__init__(self, config, ...)
	Node.__init__(self, ...)
	Node._i18n(self, config, nil, nil, ...)

	self.config = config
	self.parsechain = {self.config}
	self.template = "cbi/map"
	self.uci = uci.cursor()
	self.save = true
	if not self.uci:load(self.config) then
		error("Unable to read UCI data: " .. self.config)
	end

	self.validator = luci.uvl.UVL()
	self.scheme = self.validator:get_scheme(self.config)
	
end

function Map.get_scheme(self, sectiontype, option)
	if not option then
		return self.scheme and self.scheme.sections[sectiontype]
	else
		return self.scheme and self.scheme.variables[sectiontype]
		 and self.scheme.variables[sectiontype][option]
	end
end


-- Chain foreign config
function Map.chain(self, config)
	table.insert(self.parsechain, config)
end

-- Use optimized UCI writing
function Map.parse(self, ...)
	Node.parse(self, ...)

	if self.save then
		for i, config in ipairs(self.parsechain) do
			self.uci:save(config)
		end
		if luci.http.formvalue("cbi.apply") then
			for i, config in ipairs(self.parsechain) do
				self.uci:commit(config)
				self.uci:apply(config)
	
				-- Refresh data because commit changes section names
				self.uci:load(config)
			end
	
			-- Reparse sections
			Node.parse(self, ...)
	
		end
		for i, config in ipairs(self.parsechain) do
			self.uci:unload(config)
		end
	end
end

-- Creates a child section
function Map.section(self, class, ...)
	if instanceof(class, AbstractSection) then
		local obj  = class(self, ...)
		self:append(obj)
		return obj
	else
		error("class must be a descendent of AbstractSection")
	end
end

-- UCI add
function Map.add(self, sectiontype)
	return self.uci:add(self.config, sectiontype)
end

-- UCI set
function Map.set(self, section, option, value)
	if option then
		return self.uci:set(self.config, section, option, value)
	else
		return self.uci:set(self.config, section, value)
	end
end

-- UCI del
function Map.del(self, section, option)
	if option then
		return self.uci:delete(self.config, section, option)
	else
		return self.uci:delete(self.config, section)
	end
end

-- UCI get
function Map.get(self, section, option)
	if not section then
		return self.uci:get_all(self.config)
	elseif option then
		return self.uci:get(self.config, section, option)
	else
		return self.uci:get_all(self.config, section)
	end
end


--[[
Page - A simple node
]]--

Page = class(Node)
Page.__init__ = Node.__init__
Page.parse    = function() end


--[[
SimpleForm - A Simple non-UCI form
]]--
SimpleForm = class(Node)

function SimpleForm.__init__(self, config, title, description, data)
	Node.__init__(self, title, description)
	self.config = config
	self.data = data or {}
	self.template = "cbi/simpleform"
	self.dorender = true
end

function SimpleForm.parse(self, ...)
	if luci.http.formvalue("cbi.submit") then
		Node.parse(self, 1, ...)
	end

	local valid = true
	for k, j in ipairs(self.children) do
		for i, v in ipairs(j.children) do
			valid = valid
			 and (not v.tag_missing or not v.tag_missing[1])
			 and (not v.tag_invalid or not v.tag_invalid[1])
		end
	end

	local state =
		not luci.http.formvalue("cbi.submit") and 0
		or valid and 1
		or -1

	self.dorender = not self.handle or self:handle(state, self.data) ~= false
end

function SimpleForm.render(self, ...)
	if self.dorender then
		Node.render(self, ...)
	end
end

function SimpleForm.section(self, class, ...)
	if instanceof(class, AbstractSection) then
		local obj  = class(self, ...)
		self:append(obj)
		return obj
	else
		error("class must be a descendent of AbstractSection")
	end
end

-- Creates a child field
function SimpleForm.field(self, class, ...)
	local section
	for k, v in ipairs(self.children) do
		if instanceof(v, SimpleSection) then
			section = v
			break
		end
	end
	if not section then
		section = self:section(SimpleSection)
	end

	if instanceof(class, AbstractValue) then
		local obj  = class(self, section, ...)
		obj.track_missing = true
		section:append(obj)
		return obj
	else
		error("class must be a descendent of AbstractValue")
	end
end

function SimpleForm.set(self, section, option, value)
	self.data[option] = value
end


function SimpleForm.del(self, section, option)
	self.data[option] = nil
end


function SimpleForm.get(self, section, option)
	return self.data[option]
end


function SimpleForm.get_scheme()
	return nil
end



--[[
AbstractSection
]]--
AbstractSection = class(Node)

function AbstractSection.__init__(self, map, sectiontype, ...)
	Node.__init__(self, ...)
	self.sectiontype = sectiontype
	self.map = map
	self.config = map.config
	self.optionals = {}
	self.defaults = {}
	self.fields = {}
	self.tag_error = {}
	self.tag_invalid = {}
	self.tag_deperror = {}

	self.optional = true
	self.addremove = false
	self.dynamic = false
end

-- Appends a new option
function AbstractSection.option(self, class, option, ...)
	-- Autodetect from UVL
	if class == true and self.map:get_scheme(self.sectiontype, option) then
		local vs = self.map:get_scheme(self.sectiontype, option)
		if vs.type == "boolean" then
			class = Flag
		elseif vs.type == "list" then
			class = DynamicList
		elseif vs.type == "enum" or vs.type == "reference" then
			class = ListValue
		else
			class = Value
		end
	end

	if instanceof(class, AbstractValue) then
		local obj  = class(self.map, self, option, ...)

		Node._i18n(obj, self.config, self.section or self.sectiontype, option, ...)

		self:append(obj)
		self.fields[option] = obj
		return obj
	elseif class == true then
		error("No valid class was given and autodetection failed.")
	else
		error("class must be a descendant of AbstractValue")
	end
end

-- Parse optional options
function AbstractSection.parse_optionals(self, section)
	if not self.optional then
		return
	end

	self.optionals[section] = {}

	local field = luci.http.formvalue("cbi.opt."..self.config.."."..section)
	for k,v in ipairs(self.children) do
		if v.optional and not v:cfgvalue(section) then
			if field == v.option then
				field = nil
			else
				table.insert(self.optionals[section], v)
			end
		end
	end

	if field and #field > 0 and self.dynamic then
		self:add_dynamic(field)
	end
end

-- Add a dynamic option
function AbstractSection.add_dynamic(self, field, optional)
	local o = self:option(Value, field, field)
	o.optional = optional
end

-- Parse all dynamic options
function AbstractSection.parse_dynamic(self, section)
	if not self.dynamic then
		return
	end

	local arr  = luci.util.clone(self:cfgvalue(section))
	local form = luci.http.formvaluetable("cbid."..self.config.."."..section)
	for k, v in pairs(form) do
		arr[k] = v
	end

	for key,val in pairs(arr) do
		local create = true

		for i,c in ipairs(self.children) do
			if c.option == key then
				create = false
			end
		end

		if create and key:sub(1, 1) ~= "." then
			self:add_dynamic(key, true)
		end
	end
end

-- Returns the section's UCI table
function AbstractSection.cfgvalue(self, section)
	return self.map:get(section)
end

-- Removes the section
function AbstractSection.remove(self, section)
	return self.map:del(section)
end

-- Creates the section
function AbstractSection.create(self, section)
	local stat

	if section then
		stat = self.map:set(section, nil, self.sectiontype)
	else
		section = self.map:add(self.sectiontype)
		stat = section
	end

	if stat then
		for k,v in pairs(self.children) do
			if v.default then
				self.map:set(section, v.option, v.default)
			end
		end

		for k,v in pairs(self.defaults) do
			self.map:set(section, k, v)
		end
	end

	return stat
end


SimpleSection = class(AbstractSection)

function SimpleSection.__init__(self, form, ...)
	AbstractSection.__init__(self, form, nil, ...)
	self.template = "cbi/nullsection"
end


Table = class(AbstractSection)

function Table.__init__(self, form, data, ...)
	local datasource = {}
	datasource.config = "table"
	self.data = data

	function datasource.get(self, section, option)
		return data[section] and data[section][option]
	end

	function datasource.del(...)
		return true
	end

	function datasource.get_scheme()
		return nil
	end

	AbstractSection.__init__(self, datasource, "table", ...)
	self.template = "cbi/tblsection"
	self.rowcolors = true
	self.anonymous = true
end

function Table.parse(self)
	for i, k in ipairs(self:cfgsections()) do
		if luci.http.formvalue("cbi.submit") then
			Node.parse(self, k)
		end
	end
end

function Table.cfgsections(self)
	local sections = {}

	for i, v in luci.util.kspairs(self.data) do
		table.insert(sections, i)
	end

	return sections
end



--[[
NamedSection - A fixed configuration section defined by its name
]]--
NamedSection = class(AbstractSection)

function NamedSection.__init__(self, map, section, stype, ...)
	AbstractSection.__init__(self, map, stype, ...)
	Node._i18n(self, map.config, section, nil, ...)
	
	-- Defaults
	self.addremove = false

	-- Use defaults from UVL
	if not self.override_scheme and self.map:get_scheme(self.sectiontype) then
		local vs = self.map:get_scheme(self.sectiontype)
		self.addremove = not vs.unique and not vs.required
		self.dynamic   = vs.dynamic
		self.title       = self.title or vs.title
		self.description = self.description or vs.descr
	end

	self.template = "cbi/nsection"
	self.section = section
end

function NamedSection.parse(self)
	local s = self.section
	local active = self:cfgvalue(s)

	if self.addremove then
		local path = self.config.."."..s
		if active then -- Remove the section
			if luci.http.formvalue("cbi.rns."..path) and self:remove(s) then
				return
			end
		else           -- Create and apply default values
			if luci.http.formvalue("cbi.cns."..path) then
				self:create(s)
				return
			end
		end
	end

	if active then
		AbstractSection.parse_dynamic(self, s)
		if luci.http.formvalue("cbi.submit") then
			Node.parse(self, s)
			
			if not self.override_scheme and self.map.scheme then
				local co = self.map:get()
				local stat, err = self.map.validator:validate_section(self.config, s, co)
				if err then
					self.map.save = false
					if err.code == luci.uvl.errors.ERR_DEPENDENCY then
						self.tag_deperror[s] = true
					else
						self.tag_invalid[s] = true
					end
					for i, v in ipairs(err.childs) do
						if v.option and self.fields[v.option] then
							if v.code == luci.uvl.errors.ERR_DEPENDENCY then
								self.fields[v.option].tag_reqerror[s] = true
							elseif v.code == luci.uvl.errors.ERR_OPTION then
								self.fields[v.option].tag_invalid[s] = true
							end
						end
					end
				end
			end
		end
		AbstractSection.parse_optionals(self, s)
	end
end


--[[
TypedSection - A (set of) configuration section(s) defined by the type
	addremove: 	Defines whether the user can add/remove sections of this type
	anonymous:  Allow creating anonymous sections
	validate: 	a validation function returning nil if the section is invalid
]]--
TypedSection = class(AbstractSection)

function TypedSection.__init__(self, map, type, ...)
	AbstractSection.__init__(self, map, type, ...)
	Node._i18n(self, map.config, type, nil, ...)

	self.template  = "cbi/tsection"
	self.deps = {}
	self.anonymous = false

	-- Use defaults from UVL
	if not self.override_scheme and self.map:get_scheme(self.sectiontype) then
		local vs = self.map:get_scheme(self.sectiontype)
		self.addremove = not vs.unique and not vs.required
		self.dynamic   = vs.dynamic
		self.anonymous = not vs.named
		self.title       = self.title or vs.title
		self.description = self.description or vs.descr
	end
end

-- Return all matching UCI sections for this TypedSection
function TypedSection.cfgsections(self)
	local sections = {}
	self.map.uci:foreach(self.map.config, self.sectiontype,
		function (section)
			if self:checkscope(section[".name"]) then
				table.insert(sections, section[".name"])
			end
		end)

	return sections
end

-- Limits scope to sections that have certain option => value pairs
function TypedSection.depends(self, option, value)
	table.insert(self.deps, {option=option, value=value})
end

function TypedSection.parse(self)
	if self.addremove then
		-- Create
		local crval = CREATE_PREFIX .. self.config .. "." .. self.sectiontype
		local name  = luci.http.formvalue(crval)
		if self.anonymous then
			if name then
				self:create()
			end
		else
			if name then
				-- Ignore if it already exists
				if self:cfgvalue(name) then
					name = nil;
				end

				name = self:checkscope(name)

				if not name then
					self.err_invalid = true
				end

				if name and #name > 0 then
					self:create(name)
				end
			end
		end

		-- Remove
		crval = REMOVE_PREFIX .. self.config
		name = luci.http.formvaluetable(crval)
		for k,v in pairs(name) do
			if self:cfgvalue(k) and self:checkscope(k) then
				self:remove(k)
			end
		end
	end

	local co
	for i, k in ipairs(self:cfgsections()) do
		AbstractSection.parse_dynamic(self, k)
		if luci.http.formvalue("cbi.submit") then
			Node.parse(self, k)
			
			if not self.override_scheme and self.map.scheme then
				local co = self.map:get()
				local stat, err = self.map.validator:validate_section(self.config, k, co)
				if err then
					self.map.save = false
					if err.code == luci.uvl.errors.ERR_DEPENDENCY then
						self.tag_deperror[k] = true
					else
						self.tag_invalid[k] = true
					end
					for i, v in ipairs(err.childs) do
						if v.option and self.fields[v.option] then
							if v.code == luci.uvl.errors.ERR_DEPENDENCY then
								self.fields[v.option].tag_reqerror[k] = true
							elseif v.code == luci.uvl.errors.ERR_OPTION then
								self.fields[v.option].tag_invalid[k] = true
							end
						end
					end
				end
			end
		end
		AbstractSection.parse_optionals(self, k)
	end
end

-- Verifies scope of sections
function TypedSection.checkscope(self, section)
	-- Check if we are not excluded
	if self.filter and not self:filter(section) then
		return nil
	end

	-- Check if at least one dependency is met
	if #self.deps > 0 and self:cfgvalue(section) then
		local stat = false

		for k, v in ipairs(self.deps) do
			if self:cfgvalue(section)[v.option] == v.value then
				stat = true
			end
		end

		if not stat then
			return nil
		end
	end

	return self:validate(section)
end


-- Dummy validate function
function TypedSection.validate(self, section)
	return section
end


--[[
AbstractValue - An abstract Value Type
	null:		Value can be empty
	valid:		A function returning the value if it is valid otherwise nil
	depends:	A table of option => value pairs of which one must be true
	default:	The default value
	size:		The size of the input fields
	rmempty:	Unset value if empty
	optional:	This value is optional (see AbstractSection.optionals)
]]--
AbstractValue = class(Node)

function AbstractValue.__init__(self, map, section, option, ...)
	Node.__init__(self, ...)
	self.section = section
	self.option  = option
	self.map     = map
	self.config  = map.config
	self.tag_invalid = {}
	self.tag_missing = {}
	self.tag_reqerror = {}
	self.tag_error = {}
	self.deps = {}
	self.cast = "string"

	self.track_missing = false
	self.rmempty   = false
	self.default   = nil
	self.size      = nil
	self.optional  = false

	-- Use defaults from UVL
	if not self.override_scheme
	 and self.map:get_scheme(self.section.sectiontype, self.option) then
		local vs = self.map:get_scheme(self.section.sectiontype, self.option)
		self.rmempty     = not vs.required
		self.cast        = (vs.type == "list") and "list" or "string"
		self.title       = self.title or vs.title
		self.description = self.description or vs.descr

		if vs.depends and not self.override_dependencies then
			for i, deps in ipairs(vs.depends) do
				deps = _uvl_strip_remote_dependencies(deps)
				if next(deps) then
					self:depends(deps)
				end
			end
		end
	end
end

-- Add a dependencie to another section field
function AbstractValue.depends(self, field, value)
	local deps
	if type(field) == "string" then
		deps = {}
	 	deps[field] = value
	else
		deps = field
	end

	table.insert(self.deps, {deps=deps, add=""})
end

-- Generates the unique CBID
function AbstractValue.cbid(self, section)
	return "cbid."..self.map.config.."."..section.."."..self.option
end

-- Return whether this object should be created
function AbstractValue.formcreated(self, section)
	local key = "cbi.opt."..self.config.."."..section
	return (luci.http.formvalue(key) == self.option)
end

-- Returns the formvalue for this object
function AbstractValue.formvalue(self, section)
	return luci.http.formvalue(self:cbid(section))
end

function AbstractValue.additional(self, value)
	self.optional = value
end

function AbstractValue.mandatory(self, value)
	self.rmempty = not value
end

function AbstractValue.parse(self, section)
	local fvalue = self:formvalue(section)
	local cvalue = self:cfgvalue(section)

	if fvalue and fvalue ~= "" then -- If we have a form value, write it to UCI
		fvalue = self:transform(self:validate(fvalue, section))
		if not fvalue then
			self.tag_invalid[section] = true
		end
		if fvalue and not (fvalue == cvalue) then
			self:write(section, fvalue)
		end
	else							-- Unset the UCI or error
		if self.rmempty or self.optional then
			self:remove(section)
		elseif self.track_missing and (not fvalue or fvalue ~= cvalue) then
			self.tag_missing[section] = true
		end
	end
end

-- Render if this value exists or if it is mandatory
function AbstractValue.render(self, s, scope)
	if not self.optional or self:cfgvalue(s) or self:formcreated(s) then
		scope = scope or {}
		scope.section   = s
		scope.cbid      = self:cbid(s)
		scope.striptags = luci.util.striptags

		scope.ifattr = function(cond,key,val)
			if cond then
				return string.format(
					' %s="%s"', tostring(key),
					luci.util.pcdata(tostring( val
					 or scope[key]
					 or (type(self[key]) ~= "function" and self[key])
					 or "" ))
				)
			else
				return ''
			end
		end

		scope.attr = function(...)
			return scope.ifattr( true, ... )
		end

		Node.render(self, scope)
	end
end

-- Return the UCI value of this object
function AbstractValue.cfgvalue(self, section)
	local value = self.map:get(section, self.option)
	if not self.cast or self.cast == type(value) then
		return value
	elseif self.cast == "string" then
		if type(value) == "table" then
			return value[1]
		end
	elseif self.cast == "table" then
		return {value}
	end
end

-- Validate the form value
function AbstractValue.validate(self, value)
	return value
end

AbstractValue.transform = AbstractValue.validate


-- Write to UCI
function AbstractValue.write(self, section, value)
	return self.map:set(section, self.option, value)
end

-- Remove from UCI
function AbstractValue.remove(self, section)
	return self.map:del(section, self.option)
end




--[[
Value - A one-line value
	maxlength:	The maximum length
]]--
Value = class(AbstractValue)

function Value.__init__(self, ...)
	AbstractValue.__init__(self, ...)
	self.template  = "cbi/value"
	self.keylist = {}
	self.vallist = {}
end

function Value.value(self, key, val)
	val = val or key
	table.insert(self.keylist, tostring(key))
	table.insert(self.vallist, tostring(val))
end


-- DummyValue - This does nothing except being there
DummyValue = class(AbstractValue)

function DummyValue.__init__(self, ...)
	AbstractValue.__init__(self, ...)
	self.template = "cbi/dvalue"
	self.value = nil
end

function DummyValue.parse(self)

end


--[[
Flag - A flag being enabled or disabled
]]--
Flag = class(AbstractValue)

function Flag.__init__(self, ...)
	AbstractValue.__init__(self, ...)
	self.template  = "cbi/fvalue"

	self.enabled = "1"
	self.disabled = "0"
end

-- A flag can only have two states: set or unset
function Flag.parse(self, section)
	local fvalue = self:formvalue(section)

	if fvalue then
		fvalue = self.enabled
	else
		fvalue = self.disabled
	end

	if fvalue == self.enabled or (not self.optional and not self.rmempty) then
		if not(fvalue == self:cfgvalue(section)) then
			self:write(section, fvalue)
		end
	else
		self:remove(section)
	end
end



--[[
ListValue - A one-line value predefined in a list
	widget: The widget that will be used (select, radio)
]]--
ListValue = class(AbstractValue)

function ListValue.__init__(self, ...)
	AbstractValue.__init__(self, ...)
	self.template  = "cbi/lvalue"

	self.keylist = {}
	self.vallist = {}
	self.size   = 1
	self.widget = "select"

	if not self.override_scheme
	 and self.map:get_scheme(self.section.sectiontype, self.option) then
		local vs = self.map:get_scheme(self.section.sectiontype, self.option)
		if self.value and vs.values and not self.override_values then
			if self.rmempty or self.optional then
				self:value("")
			end
			for k, v in pairs(vs.values) do
				local deps = {}
				if not self.override_dependencies
				 and vs.enum_depends and vs.enum_depends[k] then
					for i, dep in ipairs(vs.enum_depends[k]) do
						table.insert(deps, _uvl_strip_remote_dependencies(dep))
					end
				end
				self:value(k, v, unpack(deps))
			end
		end
	end
end

function ListValue.value(self, key, val, ...)
	if luci.util.contains(self.keylist, key) then
		return
	end

	val = val or key
	table.insert(self.keylist, tostring(key))
	table.insert(self.vallist, tostring(val))

	for i, deps in ipairs({...}) do
		table.insert(self.deps, {add = "-"..key, deps=deps})
	end
end

function ListValue.validate(self, val)
	if luci.util.contains(self.keylist, val) then
		return val
	else
		return nil
	end
end



--[[
MultiValue - Multiple delimited values
	widget: The widget that will be used (select, checkbox)
	delimiter: The delimiter that will separate the values (default: " ")
]]--
MultiValue = class(AbstractValue)

function MultiValue.__init__(self, ...)
	AbstractValue.__init__(self, ...)
	self.template = "cbi/mvalue"

	self.keylist = {}
	self.vallist = {}

	self.widget = "checkbox"
	self.delimiter = " "
end

function MultiValue.render(self, ...)
	if self.widget == "select" and not self.size then
		self.size = #self.vallist
	end

	AbstractValue.render(self, ...)
end

function MultiValue.value(self, key, val)
	if luci.util.contains(self.keylist, key) then
		return
	end

	val = val or key
	table.insert(self.keylist, tostring(key))
	table.insert(self.vallist, tostring(val))
end

function MultiValue.valuelist(self, section)
	local val = self:cfgvalue(section)

	if not(type(val) == "string") then
		return {}
	end

	return luci.util.split(val, self.delimiter)
end

function MultiValue.validate(self, val)
	val = (type(val) == "table") and val or {val}

	local result

	for i, value in ipairs(val) do
		if luci.util.contains(self.keylist, value) then
			result = result and (result .. self.delimiter .. value) or value
		end
	end

	return result
end


StaticList = class(MultiValue)

function StaticList.__init__(self, ...)
	MultiValue.__init__(self, ...)
	self.cast = "table"
	self.valuelist = self.cfgvalue

	if not self.override_scheme
	 and self.map:get_scheme(self.section.sectiontype, self.option) then
		local vs = self.map:get_scheme(self.section.sectiontype, self.option)
		if self.value and vs.values and not self.override_values then
			for k, v in pairs(vs.values) do
				self:value(k, v)
			end
		end
	end
end

function StaticList.validate(self, value)
	value = (type(value) == "table") and value or {value}

	local valid = {}
	for i, v in ipairs(value) do
		if luci.util.contains(self.valuelist, v) then
			table.insert(valid, v)
		end
	end
	return valid
end


DynamicList = class(AbstractValue)

function DynamicList.__init__(self, ...)
	AbstractValue.__init__(self, ...)
	self.template  = "cbi/dynlist"
	self.cast = "table"
	self.keylist = {}
	self.vallist = {}
end

function DynamicList.value(self, key, val)
	val = val or key
	table.insert(self.keylist, tostring(key))
	table.insert(self.vallist, tostring(val))
end

function DynamicList.validate(self, value, section)
	value = (type(value) == "table") and value or {value}

	local valid = {}
	for i, v in ipairs(value) do
		if v and #v > 0 and
		 not luci.http.formvalue("cbi.rle."..section.."."..self.option.."."..i) then
			table.insert(valid, v)
		end
	end

	return valid
end


--[[
TextValue - A multi-line value
	rows:	Rows
]]--
TextValue = class(AbstractValue)

function TextValue.__init__(self, ...)
	AbstractValue.__init__(self, ...)
	self.template  = "cbi/tvalue"
end

--[[
Button
]]--
Button = class(AbstractValue)

function Button.__init__(self, ...)
	AbstractValue.__init__(self, ...)
	self.template  = "cbi/button"
	self.inputstyle = nil
	self.rmempty = true
end