Config::Model::Value - Strongly typed configuration value
version 2.116
use Config::Model; # define configuration tree object my $model = Config::Model->new; $model ->create_config_class ( name => "MyClass", element => [ [qw/foo bar/] => { type => 'leaf', value_type => 'string', description => 'foobar', } , country => { type => 'leaf', value_type => 'enum', choice => [qw/France US/], description => 'big countries', } , ], ) ; my $inst = $model->instance(root_class_name => 'MyClass' ); my $root = $inst->config_root ; # put data $root->load( steps => 'foo=FOO country=US' ); print $root->report ; # foo = FOO # DESCRIPTION: foobar # # country = US # DESCRIPTION: big countries
This class provides a way to specify configuration value with the following properties:
Strongly typed scalar: the value can either be an enumerated type, a boolean, a number, an integer or a string
default parameter: a value can have a default value specified during the construction. This default value is written in the target configuration file. (default parameter)
default
upstream default parameter: specifies a default value that is used by the application when no information is provided in the configuration file. This upstream_default value is not written in the configuration files. Only the fetch_standard method returns the builtin value. This parameter was previously referred as built_in value. This may be used for audit purpose. (upstream_default parameter)
fetch_standard
built_in
upstream_default
mandatory value: reading a mandatory value raises an exception if the value is not specified and has no default value.
dynamic change of property: A slave value can be registered to another master value so that the properties of the slave value can change according to the value of the master value. For instance, paper size value can be 'letter' for country 'US' and 'A4' for country 'France'.
A reference to the Id of a hash of list element. In other word, the value is an enumerated type where the possible values (choice) is defined by the existing keys of a has element somewhere in the tree. See "Value Reference".
There are several kind of default values. They depend on where these values are defined (or found).
From the lowest default level to the "highest":
upstream_default: The value is known in the application, but is not written in the configuration file.
layered: The value is known by the application through another mean (e.g. an included configuration file), but is not written in the configuration file.
layered
default: The value is known by the model, but not by the application. This value must be written in the configuration file.
computed: The value is computed from other configuration elements. This value must be written in the configuration file.
computed
preset: The value is not known by the model or by the application. But it can be found by an automatic program and stored while the configuration Config::Model::Instance is in preset mode
preset
Then there is the value entered by the user. This overrides all kind of "default" value.
The fetch_standard function returns the "highest" level of default value, but does not return a custom value, i.e. a value entered by the user.
Value object should not be created directly.
A leaf element must be declared with the following parameters:
Either boolean, enum, integer, number, uniline, string, file, dir. Mandatory. See "Value types".
boolean
enum
integer
number
uniline
string
file
dir
Specify the default value (optional)
Specify a built in default value (optional). I.e a value known by the application which does not need to be written in the configuration file.
Array ref. Reserved for boolean value. Specify how to write a boolean value. Default is [0,1] which may not be the most readable. write_as can be specified as ['false','true'] or ['no','yes'].
[0,1]
write_as
['false','true']
['no','yes']
Computes a value according to a formula and other values. By default a computed value cannot be set. See Config::Model::ValueComputer for computed value declaration.
This is a special parameter to cater for smooth configuration upgrade. This parameter can be used to copy the value of a deprecated parameter to its replacement. See "Upgrade" for details.
When stored, the value is converted to uppercase (uc) or lowercase (lc).
Specify the minimum value (optional, only for integer, number)
Specify the maximum value (optional, only for integer, number)
Set to 1 if the configuration value must be set by the configuration user (default: 0)
Array ref of the possible value of an enum. Example :
choice => [ qw/foo bar/]
Perl regular expression. The value is matched with the regex to assert its validity. Example match => '^foo' means that the parameter value must begin with "foo". Valid only for string or uniline values.
match => '^foo'
Hash ref. Keys are made of Perl regular expression. The value can specify a warning message (leave empty or undefined for a default warning message) and instructions to fix the value. A warning is issued when the value matches the passed regular expression. Valid only for string or uniline values. The fix instructions is evaluated when apply_fixes is called. $_ contains the value to fix. $_ is stored as the new value once the instructions are done. $self contains the value object. Use with care.
$_
$self
In the example below, any value matching 'foo' is converted in uppercase:
warn_if_match => { 'foo' => { fix => 'uc;', msg => 'value $_ contains foo' }, 'BAR' => { fix =>'lc;', msg => 'value $_ contains BAR' } },
The tests are done in alphabetical order. In the example above, BAR test is done before foo test.
BAR
foo
$_ is substituted with the bad value when the message is generated. $std_value is substituted with the standard value (i.e the preset, computed or default value).
$std_value
Hash ref like above. A warning is issued when the value does not match the passed regular expression. Valid only for string or uniline values.
String. Issue a warning to user with the specified string any time a value is set or read.
A bit like warn_if_match. The hash key is not a regexp but a label to help users. The hash ref contains some Perl code that is evaluated to perform the test. A warning is issued if the given code returns true.
warn_if_match
$_ contains the value to check. $self contains the Config::Model::Value object (use with care).
Config::Model::Value
The example below warns if value contaims a number:
warn_if => { warn_test => { code => 'defined $_ && /\d/;', msg => 'value $_ should not have numbers', fix => 's/\d//g;' } },
Any operation or check on file must be done with file sub (otherwise tests will break). This sub returns a Path::Tiny object that can be used to perform checks. For instance:
warn_if => { warn_test => { code => 'not file($_)->exists', msg => 'file $_ should exist' }
Like warn_if, but issue a warning when the given code returns false.
warn_if
code
The example below warns unless the value points to an existing directory:
warn_unless => { 'dir' => { code => '-d', msg => 'missing dir', fix => "system(mkdir $_);" } }
Like warn_if. Except that returned value triggers an error when the given code returns false:
assert => { test_nb => { code => 'defined $_ && /\d/;', msg => 'should not have numbers', fix => 's/\d//g;' } },
Setup a Parse::RecDescent grammar to perform validation.
If the grammar does not start with a "check" rule (i.e does not start with "check: "), the first line of the grammar is modified to add "check" rule and this rules is set up so the entire value must match the passed grammar.
I.e. the grammar:
token (oper token)(s?) oper: 'and' | 'or' token: 'Apache' | 'CC-BY' | 'Perl'
is changed to
check: token (oper token)(s?) /^\Z/ {$return = 1;} oper: 'and' | 'or' token: 'Apache' | 'CC-BY' | 'Perl'
The rule is called with Value object and a string reference. So, in the actions you may need to define, you can call the value object as $arg[0], store error message in ${$arg[1]}} and store warnings in ${$arg[2]}}.
$arg[0]
${$arg[1]}}
${$arg[2]}}
Hash ref. Used for enum to substitute one value with another. This parameter must be used to enable user to upgrade a configuration with obsolete values. For instance, if the value foo is obsolete and replaced by foo_better, you must declare:
foo_better
replace => { foo => 'foo_better' }
The hash key can also be a regular expression for wider range replacement. The regexp must match the whole value:
replace => ( 'foo.*' => 'better_foo' }
In this case, a value is replaced by better_foo when the /^foo.*$/ regexp matches.
better_foo
/^foo.*$/
Path specifying a hash of value element in the configuration tree. The hash if used in a way similar to the replace parameter. In this case, the replacement is not coded in the model but specified by the configuration.
replace
Specify a path to an id element used as a reference. See "Value Reference" for details.
Specify a path to an id element used as a computed reference. See "Value Reference" for details.
See section below: "Warp: dynamic value configuration".
You may provide detailed description on possible values with a hash ref. Example:
help => { oui => "French for 'yes'", non => "French for 'no'"}
This modules can check several value types:
Accepts values 1 or 0, yes or no, true or false, and empty string. The value read back is always 1 or 0.
1
0
yes
no
true
false
Enum choices must be specified by the choice parameter.
choice
Enable positive or negative integer
The value can be a decimal number
A one line string. I.e without "\n" in it.
Actually, no check is performed with this type.
reference
Like an enum where the possible values (aka choice) is defined by another location if the configuration tree. See "Value Reference".
A file name or path. A warning is issued if the file does not exists (or is a directory)
A directory name or path. A warning is issued if the directory does not exists (or is a plain file)
The Warp functionality enable a Value object to change its properties (i.e. default value or its type) dynamically according to the value of another Value object locate elsewhere in the configuration tree. (See Config::Model::Warper for an explanation on warp mechanism).
Value
For instance if you declare 2 Value element this way:
$model ->create_config_class ( name => "TV_config_class", element => [ country => { type => 'leaf', value_type => 'enum', choice => [qw/US Europe Japan/] } , tv_standard => { # this example is getting old... type => 'leaf', value_type => 'enum', choice => [ qw/PAL NTSC SECAM/ ] warp => { follow => { # this points to the warp master c => '- country' }, rules => { '$c eq "US"' => { default => 'NTSC' }, '$c eq "France"' => { default => 'SECAM' }, '$c eq "Japan"' => { default => 'NTSC' }, '$c eq "Europe"' => { default => 'PAL' }, } } } , ] );
Setting country element to US means that tv_standard has a default value set to NTSC by the warp mechanism.
country
US
tv_standard
NTSC
Likewise, the warp mechanism enables you to dynamically change the possible values of an enum element:
state => { type => 'leaf', value_type => 'enum', # example is admittedly silly warp => { follow => { c => '- country' }, rules => { '$c eq "US"' => { choice => ['Kansas', 'Texas' ] }, '$c eq "Europe"' => { choice => ['France', 'Spain' ] }, '$c eq "Japan"' => { choice => ['Honshu', 'Hokkaido' ] } } } }
Warping value can be cascaded: A can be warped by B which can be warped by C. But this feature should be avoided since it can lead to a model very hard to debug. Bear in mind that:
A
B
C
Warp loops are not detected and end up in "deep recursion subroutine" failures.
avoid "diamond" shaped warp dependencies: the results depends on the order of the warp algorithm which can be unpredictable in this case
The keys declared in the warp rules (US, Europe and Japan in the example above) cannot be checked at start time against the warp master Value. So a wrong warp rule key is silently ignored during start up and fails at run time.
Europe
Japan
To set up an enumerated value where the possible choice depends on the key of a Config::Model::AnyId object, you must:
Set value_type to reference.
value_type
Specify the refer_to or computed_refer_to parameter. See refer_to parameter.
refer_to
computed_refer_to
In this case, a IdElementReference object is created to handle the relation between this value object and the referred Id. See Config::Model::IdElementReference for details.
IdElementReference
The following methods returns the current value of the parameter of the value object (as declared in the model unless they were warped):
Returns the object name.
Returns leaf.
leaf
Returns true if the value object can be assigned to. Return 0 for a read-only value (i.e. a computed value with no override allowed).
Query legal values (only for enum types). Return an array (possibly empty).
Returns the help strings passed to the constructor.
With on_value parameter, returns the help string dedicated to the passed value or undef.
on_value
Without parameter returns a hash ref that contains all the help strings.
Returns the error messages of this object (if any)
Returns warning concerning this value. Returns a list in list context and a string in scalar context.
Check the consistency of the value.
check_value also accepts named parameters:
check_value
When non null, check does not try to get extra information from the tree. This is required in some cases to avoid loops in check, get_info, get_warp_info, re-check ...
In scalar context, return 0 or 1.
In array context, return an empty array when no error was found. In case of errors, returns an array of error strings that should be shown to the user.
Returns the number of fixes that can be applied to the current value.
Applies the fixes to suppress the current warnings.
Like "check_value".
Also displays warnings on STDOUT unless silent parameter is set to 1. In this case,user is expected to retrieve them with "warning_msg".
silent
Without value argument, this method checks the value currently stored.
value
Can be called as value => ..., check => yes|no|skip ), silent => 0|1
value => ..., check => yes|no|skip ), silent => 0|1
Store value in leaf element. check parameter can be used to skip validation check (default ies 'yes'). silent cane be used to suppress warnings.
check
Optional callback is now deprecated.
callback
Clear the stored value. Further read returns the default value (or computed or migrated value).
Load scalar data. Data is forwarded to "store( $value )".
Called with load_data( $value ) or load_data( data = $value )> or with the same parameters are store method.
load_data( $value )
load_data( data =
store
Returns the stored value if this value is different from a standard setting or built in setting. In other words, returns undef if the stored value is identical to the default value or the computed value or the built in value.
Returns the standard value as defined by the configuration model. The standard value can be either a preset value, a layered value, a computed value, a default value or a built-in default value.
Return true if the value contains information different from default or upstream default value.
Check and fetch value from leaf element. The method can have one parameter (the fetch mode) or several pairs:
Whether to fetch default, custom, etc value. See below for details
Whether to check if the value is valid or not before returning it. Default is 'yes'. Possible value are
Perform check and raise an exception for bad values
Perform check and return undef for bad values. A warning is issued when a bad value is skipped. Set check to no to avoid warnings.
Do not check and return values even if bad
When set to 1, warning are not displayed on STDOUT. User is expected to read warnings with warning_msg method.
According to the mode parameter, this method returns either:
mode
Value entered by user or default value if the value is different from upstream_default or layered value. Typically this value is written in a configuration file.
Alias for default mode.
The value entered by the user (if different from built in, preset, computed or default value)
The value most useful to user: the value that is used by the application.
The value entered in preset mode
The preset or computed or default or built in value.
The default value (defined by the configuration model)
The value found in included files (treated in layered mode: values specified there are handled as upstream default values). E.g. like in multistrap config.
The upstream_default value. (defined by the configuration model)
The custom or preset or computed or default value. Returns undef if either of this value is identical to the upstream_default value. This feature is useful to reduce data to write in configuration file.
With this mode, fetch() returns undef for mandatory values. Normally, trying to fetch an undefined mandatory value leads to an exception.
fetch()
Returns the value entered by the user. Does not use the default or computed value. Returns undef unless a value was actually stored.
Returns the value entered in preset mode. Does not use the default or computed value. Returns undef unless a value was actually stored in preset mode.
Delete the preset value. (Even out of preset mode). Returns true if other data are still stored in the value (layered or user data). Returns false otherwise.
Returns the value entered in layered mode. Does not use the default or computed value. Returns undef unless a value was actually stored in layered mode.
Delete the layered value. (Even out of layered mode). Returns true if other data are still stored in the value (layered or user data). Returns false otherwise.
Get a value from a directory like path.
Set a value from a directory like path.
bounded_number => { type => 'leaf', value_type => 'number', min => 1, max => 4, },
mandatory_string => { type => 'leaf', value_type => 'string', mandatory => 1, }, mandatory_boolean => { type => 'leaf', value_type => 'boolean', mandatory => 1, },
Note that the help specification is optional.
enum_with_help => { type => 'leaf', value_type => 'enum', choice => [qw/a b c/], help => { a => 'a help' } },
Legacy values a1, c1 and foo/.* are replaced with a, c and foo/.
a1
c1
foo/.*
a
c
foo/
with_replace => { type => 'leaf', value_type => 'enum', choice => [qw/a b c/], replace => { a1 => 'a', c1 => 'c', 'foo/.*' => 'foo', }, },
An exception is triggered when the value does not match the match regular expression.
match
match => { type => 'leaf', value_type => 'string', match => '^foo\d{2}$', },
match_with_parse_recdescent => { type => 'leaf', value_type => 'string', grammar => q{ token (oper token)(s?) oper: 'and' | 'or' token: 'Apache' | 'CC-BY' | 'Perl' }, },
Issue a warning if the string contains upper case letters. Propose a fix that translate all capital letters to lower case.
warn_if_capital => { type => 'leaf', value_type => 'string', warn_if_match => { '/A-Z/' => { fix => '$_ = lc;' } }, },
A specific warning can be specified:
warn_if_capital => { type => 'leaf', value_type => 'string', warn_if_match => { '/A-Z/' => { fix => '$_ = lc;', mesg => 'NO UPPER CASE PLEASE' } }, },
warn_unless => { type => 'leaf', value_type => 'string', warn_unless_match => { foo => { msg => '', fix => '$_ = "foo".$_;' } }, },
always_warn => { type => 'leaf', value_type => 'string', warn => 'Always warn whenever used', },
See "Examples" in Config::Model::ValueComputer.
Upgrade is a special case when the configuration of an application has changed. Some parameters can be removed and replaced by another one. To avoid trouble on the application user side, Config::Model offers a possibility to handle the migration of configuration data through a special declaration in the configuration model.
This declaration must:
Declare the deprecated parameter with a status set to deprecated
status
deprecated
Declare the new parameter with the instructions to load the semantic content from the deprecated parameter. These instructions are declared in the migrate_from parameters (which is similar to the compute parameter)
migrate_from
compute
Here an example where a URL parameter is changed to a set of 2 parameters (host and path):
'old_url' => { type => 'leaf', value_type => 'uniline', status => 'deprecated', }, 'host' => { type => 'leaf', value_type => 'uniline', # the formula must end with '$1' so the result of the capture is used # as the host value migrate_from => { formula => '$old =~ m!http://([\w\.]+)!; $1 ;', variables => { old => '- old_url' }, use_eval => 1, }, }, 'path' => { type => 'leaf', value_type => 'uniline', migrate_from => { formula => '$old =~ m!http://[\w\.]+(/.*)!; $1 ;', variables => { old => '- old_url' }, use_eval => 1, }, },
When an error is encountered, this module may throw the following exceptions:
Config::Model::Exception::Model Config::Model::Exception::Formula Config::Model::Exception::WrongValue Config::Model::Exception::WarpError
See Config::Model::Exception for more details.
Dominique Dumont, (ddumont at cpan dot org)
Config::Model, Config::Model::Node, Config::Model::AnyId, Config::Model::Warper, Config::Model::Exception Config::Model::ValueComputer,
Dominique Dumont
This software is Copyright (c) 2005-2017 by Dominique Dumont.
This is free software, licensed under:
The GNU Lesser General Public License, Version 2.1, February 1999
To install Config::Model, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Config::Model
CPAN shell
perl -MCPAN -e shell install Config::Model
For more information on module installation, please visit the detailed CPAN module installation guide.