summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/spack/spack/build_systems/autotools.py160
-rw-r--r--lib/spack/spack/test/build_systems.py27
2 files changed, 151 insertions, 36 deletions
diff --git a/lib/spack/spack/build_systems/autotools.py b/lib/spack/spack/build_systems/autotools.py
index afabb90820..b78d3ed026 100644
--- a/lib/spack/spack/build_systems/autotools.py
+++ b/lib/spack/spack/build_systems/autotools.py
@@ -291,49 +291,161 @@ class AutotoolsPackage(PackageBase):
self._if_make_target_execute('test')
self._if_make_target_execute('check')
- def _activate_or_not(self, active, inactive, name, active_parameters=None):
+ def _activate_or_not(
+ self,
+ name,
+ activation_word,
+ deactivation_word,
+ activation_value=None
+ ):
+ """This function contains the current implementation details of
+ :py:meth:`~.AutotoolsPackage.with_or_without` and
+ :py:meth:`~.AutotoolsPackage.enable_or_disable`.
+
+ Args:
+ name (str): name of the variant that is being processed
+ activation_word (str): the default activation word ('with' in the
+ case of ``with_or_without``)
+ deactivation_word (str): the default deactivation word ('without'
+ in the case of ``with_or_without``)
+ activation_value (callable): callable that accepts a single
+ value. This value is either one of the allowed values for a
+ multi-valued variant or the name of a bool-valued variant.
+ Returns the parameter to be used when the value is activated.
+
+ The special value 'prefix' can also be assigned and will return
+ ``spec[name].prefix`` as activation parameter.
+
+ Examples:
+
+ Given a package with:
+
+ .. code-block:: python
+
+ variant('foo', values=('x', 'y'), description='')
+ variant('bar', default=True, description='')
+
+ calling this function like:
+
+ .. code-block:: python
+
+ _activate_or_not(
+ 'foo', 'with', 'without', activation_value='prefix'
+ )
+ _activate_or_not('bar', 'with', 'without')
+
+ will generate the following configuration options:
+
+ .. code-block:: console
+
+ --with-x=<prefix-to-x> --without-y --with-bar
+
+ for ``<spec-name> foo=x +bar``
+
+ Returns:
+ list of strings that corresponds to the activation/deactivation
+ of the variant that has been processed
+
+ Raises:
+ KeyError: if name is not among known variants
+ """
spec = self.spec
args = []
+
+ if activation_value == 'prefix':
+ activation_value = lambda x: spec[x].prefix
+
+ # Defensively look that the name passed as argument is among
+ # variants
+ if name not in self.variants:
+ msg = '"{0}" is not a variant of "{1}"'
+ raise KeyError(msg.format(name, self.name))
+
+ # Create a list of pairs. Each pair includes a configuration
+ # option and whether or not that option is activated
+ if set(self.variants[name].values) == set((True, False)):
+ # BoolValuedVariant carry information about a single option.
+ # Nonetheless, for uniformity of treatment we'll package them
+ # in an iterable of one element.
+ condition = '+{name}'.format(name=name)
+ options = [(name, condition in spec)]
+ else:
+ condition = '{name}={value}'
+ options = [
+ (value, condition.format(name=name, value=value) in spec)
+ for value in self.variants[name].values
+ ]
+
# For each allowed value in the list of values
- for value in self.variants[name].values:
- # Check if the value is active in the current spec
- condition = '{name}={value}'.format(name=name, value=value)
- activated = condition in spec
+ for option_value, activated in options:
# Search for an override in the package for this value
- override_name = '{0}_or_{1}_{2}'.format(active, inactive, value)
+ override_name = '{0}_or_{1}_{2}'.format(
+ activation_word, deactivation_word, option_value
+ )
line_generator = getattr(self, override_name, None)
# If not available use a sensible default
if line_generator is None:
def _default_generator(is_activated):
if is_activated:
- line = '--{0}-{1}'.format(active, value)
- if active_parameters is not None and active_parameters(value): # NOQA=ignore=E501
- line += '={0}'.format(active_parameters(value))
+ line = '--{0}-{1}'.format(
+ activation_word, option_value
+ )
+ if activation_value is not None and activation_value(option_value): # NOQA=ignore=E501
+ line += '={0}'.format(
+ activation_value(option_value)
+ )
return line
- return '--{0}-{1}'.format(inactive, value)
+ return '--{0}-{1}'.format(deactivation_word, option_value)
line_generator = _default_generator
args.append(line_generator(activated))
return args
- def with_or_without(self, name, active_parameters=None):
- """Inspects the multi-valued variant 'name' and returns the configure
- arguments that activate / deactivate the selected feature.
+ def with_or_without(self, name, activation_value=None):
+ """Inspects a variant and returns the arguments that activate
+ or deactivate the selected feature(s) for the configure options.
+
+ This function works on all type of variants. For bool-valued variants
+ it will return by default ``--with-{name}`` or ``--without-{name}``.
+ For other kinds of variants it will cycle over the allowed values and
+ return either ``--with-{value}`` or ``--without-{value}``.
+
+ If activation_value is given, then for each possible value of the
+ variant, the option ``--with-{value}=activation_value(value)`` or
+ ``--without-{value}`` will be added depending on whether or not
+ ``variant=value`` is in the spec.
- :param str name: name of a valid multi-valued variant
- :param callable active_parameters: if present accepts a single value
- and returns the parameter to be used leading to an entry of the
- type '--with-{name}={parameter}
+ Args:
+ name (str): name of a valid multi-valued variant
+ activation_value (callable): callable that accepts a single
+ value and returns the parameter to be used leading to an entry
+ of the type ``--with-{name}={parameter}``.
+
+ The special value 'prefix' can also be assigned and will return
+ ``spec[name].prefix`` as activation parameter.
+
+ Returns:
+ list of arguments to configure
"""
- return self._activate_or_not(
- 'with', 'without', name, active_parameters
- )
+ return self._activate_or_not(name, 'with', 'without', activation_value)
+
+ def enable_or_disable(self, name, activation_value=None):
+ """Same as :py:meth:`~.AutotoolsPackage.with_or_without` but substitute
+ ``with`` with ``enable`` and ``without`` with ``disable``.
+
+ Args:
+ name (str): name of a valid multi-valued variant
+ activation_value (callable): if present accepts a single value
+ and returns the parameter to be used leading to an entry of the
+ type ``--enable-{name}={parameter}``
+
+ The special value 'prefix' can also be assigned and will return
+ ``spec[name].prefix`` as activation parameter.
- def enable_or_disable(self, name, active_parameters=None):
- """Inspects the multi-valued variant 'name' and returns the configure
- arguments that activate / deactivate the selected feature.
+ Returns:
+ list of arguments to configure
"""
return self._activate_or_not(
- 'enable', 'disable', name, active_parameters
+ name, 'enable', 'disable', activation_value
)
run_after('install')(PackageBase._run_default_install_time_test_callbacks)
diff --git a/lib/spack/spack/test/build_systems.py b/lib/spack/spack/test/build_systems.py
index 114497bccd..9960966e2f 100644
--- a/lib/spack/spack/test/build_systems.py
+++ b/lib/spack/spack/test/build_systems.py
@@ -53,20 +53,23 @@ class TestAutotoolsPackage(object):
pkg = spack.repo.get(s)
# Called without parameters
- l = pkg.with_or_without('foo')
- assert '--with-bar' in l
- assert '--without-baz' in l
- assert '--no-fee' in l
+ options = pkg.with_or_without('foo')
+ assert '--with-bar' in options
+ assert '--without-baz' in options
+ assert '--no-fee' in options
def activate(value):
return 'something'
- l = pkg.with_or_without('foo', active_parameters=activate)
- assert '--with-bar=something' in l
- assert '--without-baz' in l
- assert '--no-fee' in l
+ options = pkg.with_or_without('foo', activation_value=activate)
+ assert '--with-bar=something' in options
+ assert '--without-baz' in options
+ assert '--no-fee' in options
- l = pkg.enable_or_disable('foo')
- assert '--enable-bar' in l
- assert '--disable-baz' in l
- assert '--disable-fee' in l
+ options = pkg.enable_or_disable('foo')
+ assert '--enable-bar' in options
+ assert '--disable-baz' in options
+ assert '--disable-fee' in options
+
+ options = pkg.with_or_without('bvv')
+ assert '--with-bvv' in options