mapnik/scons/scons-local-4.5.2/SCons/Variables/__init__.py
2023-09-22 14:38:30 +01:00

336 lines
12 KiB
Python
Vendored

# MIT License
#
# Copyright The SCons Foundation
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""Adds user-friendly customizable variables to an SCons build. """
import os.path
import sys
from functools import cmp_to_key
import SCons.Environment
import SCons.Errors
import SCons.Util
import SCons.Warnings
from .BoolVariable import BoolVariable # okay
from .EnumVariable import EnumVariable # okay
from .ListVariable import ListVariable # naja
from .PackageVariable import PackageVariable # naja
from .PathVariable import PathVariable # okay
class Variables:
"""
Holds all the options, updates the environment with the variables,
and renders the help text.
If *is_global* is true, this is a singleton, create only once.
Args:
files (optional): List of option configuration files to load
(backward compatibility). If a single string is passed it is
automatically placed in a file list (Default value = None)
args (optional): dictionary to override values set from *files*.
(Default value = None)
is_global (optional): global instance? (Default value = True)
"""
instance = None
def __init__(self, files=None, args=None, is_global=True):
if args is None:
args = {}
self.options = []
self.args = args
if not SCons.Util.is_List(files):
if files:
files = [files,]
else:
files = []
self.files = files
self.unknown = {}
# create the singleton instance
if is_global:
self = Variables.instance
if not Variables.instance:
Variables.instance=self
def _do_add(self, key, help="", default=None, validator=None, converter=None, **kwargs) -> None:
class Variable:
pass
option = Variable()
# If we get a list or a tuple, we take the first element as the
# option key and store the remaining in aliases.
if SCons.Util.is_List(key) or SCons.Util.is_Tuple(key):
option.key = key[0]
option.aliases = list(key[1:])
else:
option.key = key
# TODO: normalize to not include key in aliases. Currently breaks tests.
option.aliases = [key,]
if not SCons.Environment.is_valid_construction_var(option.key):
raise SCons.Errors.UserError("Illegal Variables key `%s'" % str(option.key))
option.help = help
option.default = default
option.validator = validator
option.converter = converter
self.options.append(option)
# options might be added after the 'unknown' dict has been set up,
# so we remove the key and all its aliases from that dict
for alias in option.aliases + [option.key,]:
if alias in self.unknown:
del self.unknown[alias]
def keys(self) -> list:
"""Returns the keywords for the options."""
return [o.key for o in self.options]
def Add(self, key, *args, **kwargs) -> None:
r""" Adds an option.
Arguments:
key: the name of the variable, or a 5-tuple (or list).
If a tuple, and there are no additional arguments,
the tuple is unpacked into the four named kwargs from below.
If a tuple and there are additional arguments, the first word
of the tuple is taken as the key, and the remainder as aliases.
*args: optional positional arguments, corresponding to the four
named kwargs below.
Keyword Args:
help: help text for the options (Default value = "")
default: default value for option (Default value = None)
validator: function called to validate the option's value
(Default value = None)
converter: function to be called to convert the option's
value before putting it in the environment. (Default value = None)
**kwargs: arbitrary keyword arguments used by the variable itself.
"""
if SCons.Util.is_List(key) or SCons.Util.is_Tuple(key):
if not (len(args) or len(kwargs)):
return self._do_add(*key)
return self._do_add(key, *args, **kwargs)
def AddVariables(self, *optlist) -> None:
""" Adds a list of options.
Each list element is a tuple/list of arguments to be passed on
to the underlying method for adding options.
Example::
opt.AddVariables(
('debug', '', 0),
('CC', 'The C compiler'),
('VALIDATE', 'An option for testing validation', 'notset', validator, None),
)
"""
for o in optlist:
self._do_add(*o)
def Update(self, env, args=None) -> None:
""" Updates an environment with the option variables.
Args:
env: the environment to update.
args (optional): a dictionary of keys and values to update
in *env*. If omitted, uses the variables from the commandline.
"""
values = {}
# first set the defaults:
for option in self.options:
if option.default is not None:
values[option.key] = option.default
# next set the value specified in the options file
for filename in self.files:
if os.path.exists(filename):
dir = os.path.split(os.path.abspath(filename))[0]
if dir:
sys.path.insert(0, dir)
try:
values['__name__'] = filename
with open(filename, 'r') as f:
contents = f.read()
exec(contents, {}, values)
finally:
if dir:
del sys.path[0]
del values['__name__']
# set the values specified on the command line
if args is None:
args = self.args
for arg, value in args.items():
added = False
for option in self.options:
if arg in option.aliases + [option.key,]:
values[option.key] = value
added = True
if not added:
self.unknown[arg] = value
# put the variables in the environment:
# (don't copy over variables that are not declared as options)
for option in self.options:
try:
env[option.key] = values[option.key]
except KeyError:
pass
# apply converters
for option in self.options:
if option.converter and option.key in values:
value = env.subst('${%s}'%option.key)
try:
try:
env[option.key] = option.converter(value)
except TypeError:
env[option.key] = option.converter(value, env)
except ValueError as x:
raise SCons.Errors.UserError('Error converting option: %s\n%s'%(option.key, x))
# apply validators
for option in self.options:
if option.validator and option.key in values:
option.validator(option.key, env.subst('${%s}'%option.key), env)
def UnknownVariables(self) -> dict:
""" Returns unknown variables.
Identifies options that were not known, declared options in this object.
"""
return self.unknown
def Save(self, filename, env) -> None:
""" Save the options to a file.
Saves all the options which have non-default settings
to the given file as Python expressions. This file can
then be used to load the options for a subsequent run.
This can be used to create an option cache file.
Args:
filename: Name of the file to save into
env: the environment get the option values from
"""
# Create the file and write out the header
try:
with open(filename, 'w') as fh:
# Make an assignment in the file for each option
# within the environment that was assigned a value
# other than the default. We don't want to save the
# ones set to default: in case the SConscript settings
# change you would then pick up old defaults.
for option in self.options:
try:
value = env[option.key]
try:
prepare = value.prepare_to_store
except AttributeError:
try:
eval(repr(value))
except KeyboardInterrupt:
raise
except:
# Convert stuff that has a repr() that
# cannot be evaluated into a string
value = SCons.Util.to_String(value)
else:
value = prepare()
defaultVal = env.subst(SCons.Util.to_String(option.default))
if option.converter:
try:
defaultVal = option.converter(defaultVal)
except TypeError:
defaultVal = option.converter(defaultVal, env)
if str(env.subst('${%s}' % option.key)) != str(defaultVal):
fh.write('%s = %s\n' % (option.key, repr(value)))
except KeyError:
pass
except IOError as x:
raise SCons.Errors.UserError('Error writing options to file: %s\n%s' % (filename, x))
def GenerateHelpText(self, env, sort=None) -> str:
""" Generates the help text for the options.
Args:
env: an environment that is used to get the current values
of the options.
sort: Either a comparison function used for sorting
(must take two arguments and return -1, 0 or 1)
or a boolean to indicate if it should be sorted.
"""
if callable(sort):
options = sorted(self.options, key=cmp_to_key(lambda x, y: sort(x.key, y.key)))
elif sort is True:
options = sorted(self.options, key=lambda x: x.key)
else:
options = self.options
def format_opt(opt, self=self, env=env) -> str:
if opt.key in env:
actual = env.subst('${%s}' % opt.key)
else:
actual = None
return self.FormatVariableHelpText(env, opt.key, opt.help, opt.default, actual, opt.aliases)
lines = [_f for _f in map(format_opt, options) if _f]
return ''.join(lines)
fmt = '\n%s: %s\n default: %s\n actual: %s\n'
aliasfmt = '\n%s: %s\n default: %s\n actual: %s\n aliases: %s\n'
def FormatVariableHelpText(self, env, key, help, default, actual, aliases=None) -> str:
if aliases is None:
aliases = []
# Don't display the key name itself as an alias.
aliases = [a for a in aliases if a != key]
if aliases:
return self.aliasfmt % (key, help, default, actual, aliases)
else:
return self.fmt % (key, help, default, actual)
# Local Variables:
# tab-width:4
# indent-tabs-mode:nil
# End:
# vim: set expandtab tabstop=4 shiftwidth=4: