Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package scons for openSUSE:Factory checked in at 2024-10-25 19:19:10 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/scons (Old) and /work/SRC/openSUSE:Factory/.scons.new.2020 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "scons" Fri Oct 25 19:19:10 2024 rev:49 rq:1218160 version:4.8.1 Changes: -------- --- /work/SRC/openSUSE:Factory/scons/scons.changes 2024-07-10 16:48:05.852494118 +0200 +++ /work/SRC/openSUSE:Factory/.scons.new.2020/scons.changes 2024-10-25 19:19:54.619296538 +0200 @@ -1,0 +2,12 @@ +Thu Oct 24 18:52:36 UTC 2024 - Andreas Stieger <andreas.stieger@gmx.de> + +- SCons 4.8.1: + * env.Dump() now accepts any number of optional "key" arguments, + and returns a dictionary string + * Fix SCons.Variables import + * Fix a problem with AppendUnique and PrependUnique where a value + could be erroneously removed due to a substring match. + * Fix handling of ListVariable when supplying a quoted choice + containing a space character + +------------------------------------------------------------------- Old: ---- SCons-4.8.0.tar.gz New: ---- SCons-4.8.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ scons.spec ++++++ --- /var/tmp/diff_new_pack.o6jOYZ/_old 2024-10-25 19:19:55.511333756 +0200 +++ /var/tmp/diff_new_pack.o6jOYZ/_new 2024-10-25 19:19:55.515333923 +0200 @@ -20,7 +20,7 @@ %define pythons python3 %{?sle15_python_module_pythons} Name: scons -Version: 4.8.0 +Version: 4.8.1 Release: 0 Summary: Replacement for Make License: MIT ++++++ SCons-4.8.0.tar.gz -> SCons-4.8.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/PKG-INFO new/scons-4.8.1/PKG-INFO --- old/scons-4.8.0/PKG-INFO 2024-07-08 01:52:31.029407500 +0200 +++ new/scons-4.8.1/PKG-INFO 2024-09-04 02:46:54.910740000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: SCons -Version: 4.8.0 +Version: 4.8.1 Summary: Open Source next-generation build tool. Author-email: William Deegan <bill@baddogconsulting.com> License: MIT diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons/Environment.py new/scons-4.8.1/SCons/Environment.py --- old/scons-4.8.0/SCons/Environment.py 2024-06-30 23:44:47.000000000 +0200 +++ new/scons-4.8.1/SCons/Environment.py 2024-09-03 04:38:32.000000000 +0200 @@ -1512,11 +1512,17 @@ self._dict[envname][name] = nv - def AppendUnique(self, delete_existing: bool=False, **kw) -> None: - """Append values to existing construction variables - in an Environment, if they're not already there. - If delete_existing is True, removes existing values first, so - values move to end. + def AppendUnique(self, delete_existing: bool = False, **kw) -> None: + """Append values uniquely to existing construction variables. + + Similar to :meth:`Append`, but the result may not contain duplicates + of any values passed for each given key (construction variable), + so an existing list may need to be pruned first, however it may still + contain other duplicates. + + If *delete_existing* is true, removes existing values first, so values + move to the end; otherwise (the default) values are skipped if + already present. """ kw = copy_non_reserved_keywords(kw) for key, val in kw.items(): @@ -1539,12 +1545,11 @@ val = [x for x in val if x not in dk] self._dict[key] = dk + val else: + # val is not a list, so presumably a scalar (likely str). dk = self._dict[key] if is_List(dk): - # By elimination, val is not a list. Since dk is a - # list, wrap val in a list first. if delete_existing: - dk = list(filter(lambda x, val=val: x not in val, dk)) + dk = [x for x in dk if x != val] self._dict[key] = dk + [val] else: if val not in dk: @@ -1694,28 +1699,37 @@ return dlist - def Dump(self, key: Optional[str] = None, format: str = 'pretty') -> str: - """ Returns a dump of serialized construction variables. + def Dump(self, *key: str, format: str = 'pretty') -> str: + """Return string of serialized construction variables. - The display formats are intended for humaan readers when - debugging - none of the supported formats produce a result that - SCons itself can directly make use of. Objects that cannot - directly be represented get a placeholder like - ``<function foo at 0x123456>`` or ``<<non-serializable: function>>``. + Produces a "pretty" output of a dictionary of selected + construction variables, or all of them. The display *format* is + selectable. The result is intended for human consumption (e.g, + to print), mainly when debugging. Objects that cannot directly be + represented get a placeholder like ``<function foo at 0x123456>`` + (pretty-print) or ``<<non-serializable: function>>`` (JSON). Args: - key: if ``None``, format the whole dict of variables, - else format just the value of *key*. + key: if omitted, format the whole dict of variables, + else format *key*(s) with the corresponding values. format: specify the format to serialize to. ``"pretty"`` generates a pretty-printed string, ``"json"`` a JSON-formatted string. Raises: ValueError: *format* is not a recognized serialization format. + + .. versionchanged:: NEXT_VERSION + *key* is no longer limited to a single construction variable name. + If *key* is supplied, a formatted dictionary is generated like the + no-arg case - previously a single *key* displayed just the value. """ - if key: - cvars = self.Dictionary(key) - else: + if not key: cvars = self.Dictionary() + elif len(key) == 1: + dkey = key[0] + cvars = {dkey: self[dkey]} + else: + cvars = dict(zip(key, self.Dictionary(*key))) fmt = format.lower() @@ -1735,14 +1749,15 @@ class DumpEncoder(json.JSONEncoder): """SCons special json Dump formatter.""" + def default(self, obj): if isinstance(obj, (UserList, UserDict)): return obj.data return f'<<non-serializable: {type(obj).__qualname__}>>' return json.dumps(cvars, indent=4, cls=DumpEncoder, sort_keys=True) - else: - raise ValueError("Unsupported serialization format: %s." % fmt) + + raise ValueError("Unsupported serialization format: %s." % fmt) def FindIxes(self, paths: Sequence[str], prefix: str, suffix: str) -> Optional[str]: @@ -1929,11 +1944,17 @@ self._dict[envname][name] = nv - def PrependUnique(self, delete_existing: bool=False, **kw) -> None: - """Prepend values to existing construction variables - in an Environment, if they're not already there. - If delete_existing is True, removes existing values first, so - values move to front. + def PrependUnique(self, delete_existing: bool = False, **kw) -> None: + """Prepend values uniquely to existing construction variables. + + Similar to :meth:`Prepend`, but the result may not contain duplicates + of any values passed for each given key (construction variable), + so an existing list may need to be pruned first, however it may still + contain other duplicates. + + If *delete_existing* is true, removes existing values first, so values + move to the front; otherwise (the default) values are skipped if + already present. """ kw = copy_non_reserved_keywords(kw) for key, val in kw.items(): @@ -1956,12 +1977,11 @@ val = [x for x in val if x not in dk] self._dict[key] = val + dk else: + # val is not a list, so presumably a scalar (likely str). dk = self._dict[key] if is_List(dk): - # By elimination, val is not a list. Since dk is a - # list, wrap val in a list first. if delete_existing: - dk = [x for x in dk if x not in val] + dk = [x for x in dk if x != val] self._dict[key] = [val] + dk else: if val not in dk: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons/Platform/win32.py new/scons-4.8.1/SCons/Platform/win32.py --- old/scons-4.8.0/SCons/Platform/win32.py 2024-02-04 21:49:23.000000000 +0100 +++ new/scons-4.8.1/SCons/Platform/win32.py 2024-09-03 04:38:32.000000000 +0200 @@ -167,7 +167,7 @@ try: with open(tmpFileStdoutName, "rb") as tmpFileStdout: output = tmpFileStdout.read() - stdout.write(output.decode(stdout.encoding, "replace")) + stdout.write(output.decode('oem', "replace").replace("\r\n", "\n")) os.remove(tmpFileStdoutName) except OSError: pass @@ -176,7 +176,7 @@ try: with open(tmpFileStderrName, "rb") as tmpFileStderr: errors = tmpFileStderr.read() - stderr.write(errors.decode(stderr.encoding, "replace")) + stderr.write(errors.decode('oem', "replace").replace("\r\n", "\n")) os.remove(tmpFileStderrName) except OSError: pass diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons/Script/Main.py new/scons-4.8.1/SCons/Script/Main.py --- old/scons-4.8.0/SCons/Script/Main.py 2024-07-08 01:48:05.000000000 +0200 +++ new/scons-4.8.1/SCons/Script/Main.py 2024-07-08 02:20:02.000000000 +0200 @@ -67,7 +67,7 @@ # these define the range of versions SCons supports minimum_python_version = (3, 6, 0) -deprecated_python_version = (3, 7, 0) # the first non-deprecated version +deprecated_python_version = (3, 7, 0) # ordered list of SConstruct names to look for if there is no -f flag KNOWN_SCONSTRUCT_NAMES = [ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons/Util/sctypes.py new/scons-4.8.1/SCons/Util/sctypes.py --- old/scons-4.8.0/SCons/Util/sctypes.py 2024-02-22 23:42:56.000000000 +0100 +++ new/scons-4.8.1/SCons/Util/sctypes.py 2024-07-22 03:13:08.000000000 +0200 @@ -11,7 +11,8 @@ import os import pprint import re -from typing import Optional +import sys +from typing import Optional, Union from collections import UserDict, UserList, UserString, deque from collections.abc import MappingView, Iterable @@ -50,38 +51,63 @@ # Empirically, it is faster to check explicitly for str than for basestring. BaseStringTypes = str +# Later Python versions allow us to explicitly apply type hints based off the +# return value similar to isinstance(), albeit not as precise. +if sys.version_info >= (3, 13): + from typing import TypeAlias, TypeIs + + DictTypeRet: TypeAlias = TypeIs[Union[dict, UserDict]] + ListTypeRet: TypeAlias = TypeIs[Union[list, UserList, deque]] + SequenceTypeRet: TypeAlias = TypeIs[Union[list, tuple, deque, UserList, MappingView]] + TupleTypeRet: TypeAlias = TypeIs[tuple] + StringTypeRet: TypeAlias = TypeIs[Union[str, UserString]] +elif sys.version_info >= (3, 10): + from typing import TypeAlias, TypeGuard + + DictTypeRet: TypeAlias = TypeGuard[Union[dict, UserDict]] + ListTypeRet: TypeAlias = TypeGuard[Union[list, UserList, deque]] + SequenceTypeRet: TypeAlias = TypeGuard[Union[list, tuple, deque, UserList, MappingView]] + TupleTypeRet: TypeAlias = TypeGuard[tuple] + StringTypeRet: TypeAlias = TypeGuard[Union[str, UserString]] +else: + DictTypeRet = Union[bool, bool] + ListTypeRet = Union[bool, bool] + SequenceTypeRet = Union[bool, bool] + TupleTypeRet = Union[bool, bool] + StringTypeRet = Union[bool, bool] + def is_Dict( # pylint: disable=redefined-outer-name,redefined-builtin obj, isinstance=isinstance, DictTypes=DictTypes -) -> bool: +) -> DictTypeRet: """Check if object is a dict.""" return isinstance(obj, DictTypes) def is_List( # pylint: disable=redefined-outer-name,redefined-builtin obj, isinstance=isinstance, ListTypes=ListTypes -) -> bool: +) -> ListTypeRet: """Check if object is a list.""" return isinstance(obj, ListTypes) def is_Sequence( # pylint: disable=redefined-outer-name,redefined-builtin obj, isinstance=isinstance, SequenceTypes=SequenceTypes -) -> bool: +) -> SequenceTypeRet: """Check if object is a sequence.""" return isinstance(obj, SequenceTypes) def is_Tuple( # pylint: disable=redefined-builtin obj, isinstance=isinstance, tuple=tuple -) -> bool: +) -> TupleTypeRet: """Check if object is a tuple.""" return isinstance(obj, tuple) def is_String( # pylint: disable=redefined-outer-name,redefined-builtin obj, isinstance=isinstance, StringTypes=StringTypes -) -> bool: +) -> StringTypeRet: """Check if object is a string.""" return isinstance(obj, StringTypes) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons/Variables/BoolVariable.py new/scons-4.8.1/SCons/Variables/BoolVariable.py --- old/scons-4.8.0/SCons/Variables/BoolVariable.py 2024-07-06 05:33:58.000000000 +0200 +++ new/scons-4.8.1/SCons/Variables/BoolVariable.py 2024-09-03 04:38:32.000000000 +0200 @@ -32,7 +32,7 @@ ... """ -from typing import Tuple, Callable +from typing import Callable, Tuple, Union import SCons.Errors @@ -42,7 +42,7 @@ FALSE_STRINGS = ('n', 'no', 'false', 'f', '0', 'off', 'none') -def _text2bool(val: str) -> bool: +def _text2bool(val: Union[str, bool]) -> bool: """Convert boolean-like string to boolean. If *val* looks like it expresses a bool-like value, based on @@ -54,6 +54,9 @@ Raises: ValueError: if *val* cannot be converted to boolean. """ + if isinstance(val, bool): + # mainly for the subst=False case: default might be a bool + return val lval = val.lower() if lval in TRUE_STRINGS: return True @@ -63,7 +66,7 @@ raise ValueError(f"Invalid value for boolean variable: {val!r}") -def _validator(key, val, env) -> None: +def _validator(key: str, val, env) -> None: """Validate that the value of *key* in *env* is a boolean. Parameter *val* is not used in the check. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons/Variables/ListVariable.py new/scons-4.8.1/SCons/Variables/ListVariable.py --- old/scons-4.8.0/SCons/Variables/ListVariable.py 2024-07-06 05:33:58.000000000 +0200 +++ new/scons-4.8.1/SCons/Variables/ListVariable.py 2024-09-03 04:38:32.000000000 +0200 @@ -81,6 +81,7 @@ if allowedElems is None: allowedElems = [] super().__init__([_f for _f in initlist if _f]) + # TODO: why sorted? don't we want to display in the order user gave? self.allowedElems = sorted(allowedElems) def __cmp__(self, other): @@ -118,6 +119,9 @@ The arguments *allowedElems* and *mapdict* are non-standard for a :class:`Variables` converter: the lambda in the :func:`ListVariable` function arranges for us to be called correctly. + + Incoming values ``all`` and ``none`` are recognized and converted + into their expanded form. """ if val == 'none': val = [] @@ -155,7 +159,7 @@ allowedElems = env[key].allowedElems if isinstance(val, _ListVariable): # not substituted, use .data notAllowed = [v for v in val.data if v not in allowedElems] - else: # val will be a string + else: # presumably a string notAllowed = [v for v in val.split() if v not in allowedElems] if notAllowed: # Converter only synthesized 'all' and 'none', they are never diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons/Variables/PackageVariable.py new/scons-4.8.1/SCons/Variables/PackageVariable.py --- old/scons-4.8.0/SCons/Variables/PackageVariable.py 2024-05-25 21:36:34.000000000 +0200 +++ new/scons-4.8.1/SCons/Variables/PackageVariable.py 2024-09-03 04:38:32.000000000 +0200 @@ -51,7 +51,7 @@ """ import os -from typing import Callable, Optional, Tuple +from typing import Callable, Optional, Tuple, Union import SCons.Errors @@ -60,13 +60,16 @@ ENABLE_STRINGS = ('1', 'yes', 'true', 'on', 'enable', 'search') DISABLE_STRINGS = ('0', 'no', 'false', 'off', 'disable') -def _converter(val): +def _converter(val: Union[str, bool]) -> Union[str, bool]: """Convert package variables. Returns True or False if one of the recognized truthy or falsy values is seen, else return the value unchanged (expected to be a path string). """ + if isinstance(val, bool): + # mainly for the subst=False case: default might be a bool + return val lval = val.lower() if lval in ENABLE_STRINGS: return True @@ -75,7 +78,7 @@ return val -def _validator(key, val, env, searchfunc) -> None: +def _validator(key: str, val, env, searchfunc) -> None: """Validate package variable for valid path. Checks that if a path is given as the value, that pathname actually exists. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons/Variables/PathVariable.py new/scons-4.8.1/SCons/Variables/PathVariable.py --- old/scons-4.8.0/SCons/Variables/PathVariable.py 2024-07-06 05:33:58.000000000 +0200 +++ new/scons-4.8.1/SCons/Variables/PathVariable.py 2024-09-03 04:38:32.000000000 +0200 @@ -93,12 +93,12 @@ """ @staticmethod - def PathAccept(key, val, env) -> None: + def PathAccept(key: str, val, env) -> None: """Validate path with no checking.""" return @staticmethod - def PathIsDir(key, val, env) -> None: + def PathIsDir(key: str, val, env) -> None: """Validate path is a directory.""" if os.path.isdir(val): return @@ -109,7 +109,7 @@ raise SCons.Errors.UserError(msg) @staticmethod - def PathIsDirCreate(key, val, env) -> None: + def PathIsDirCreate(key: str, val, env) -> None: """Validate path is a directory, creating if needed.""" if os.path.isdir(val): return @@ -123,7 +123,7 @@ raise SCons.Errors.UserError(msg) from exc @staticmethod - def PathIsFile(key, val, env) -> None: + def PathIsFile(key: str, val, env) -> None: """Validate path is a file.""" if not os.path.isfile(val): if os.path.isdir(val): @@ -133,7 +133,7 @@ raise SCons.Errors.UserError(msg) @staticmethod - def PathExists(key, val, env) -> None: + def PathExists(key: str, val, env) -> None: """Validate path exists.""" if not os.path.exists(val): msg = f'Path for variable {key!r} does not exist: {val}' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons/Variables/__init__.py new/scons-4.8.1/SCons/Variables/__init__.py --- old/scons-4.8.0/SCons/Variables/__init__.py 2024-07-06 05:33:58.000000000 +0200 +++ new/scons-4.8.1/SCons/Variables/__init__.py 2024-09-03 04:38:32.000000000 +0200 @@ -43,6 +43,11 @@ __all__ = [ "Variable", "Variables", + "BoolVariable", + "EnumVariable", + "ListVariable", + "PackageVariable", + "PathVariable", ] class Variable: @@ -56,7 +61,10 @@ def __str__(self) -> str: """Provide a way to "print" a Variable object.""" - return f"({self.key!r}, {self.aliases}, {self.help!r}, {self.default!r}, {self.validator}, {self.converter})" + return ( + f"({self.key!r}, {self.aliases}, {self.help!r}, {self.default!r}, " + f"validator={self.validator}, converter={self.converter})" + ) class Variables: @@ -282,7 +290,13 @@ for option in self.options: if option.validator and option.key in values: if option.do_subst: - value = env.subst('${%s}' % option.key) + val = env[option.key] + if not SCons.Util.is_String(val): + # issue #4585: a _ListVariable should not be further + # substituted, breaks on values with spaces. + value = val + else: + value = env.subst('${%s}' % option.key) else: value = env[option.key] option.validator(option.key, value, env) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons/__init__.py new/scons-4.8.1/SCons/__init__.py --- old/scons-4.8.0/SCons/__init__.py 2024-07-08 01:52:12.000000000 +0200 +++ new/scons-4.8.1/SCons/__init__.py 2024-09-04 02:46:37.000000000 +0200 @@ -1,9 +1,9 @@ -__version__="4.8.0" +__version__="4.8.1" __copyright__="Copyright (c) 2001 - 2024 The SCons Foundation" __developer__="bdbaddog" -__date__="Sun, 07 Jul 2024 16:52:07 -0700" +__date__="Tue, 03 Sep 2024 17:46:32 -0700" __buildsys__="M1Dog2021" -__revision__="7c688f694c644b61342670ce92977bf4a396c0d4" -__build__="7c688f694c644b61342670ce92977bf4a396c0d4" +__revision__="08661ed4c552323ef3a7f0ff1af38868cbabb05e" +__build__="08661ed4c552323ef3a7f0ff1af38868cbabb05e" # make sure compatibility is always in place import SCons.compat # noqa \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/SCons.egg-info/PKG-INFO new/scons-4.8.1/SCons.egg-info/PKG-INFO --- old/scons-4.8.0/SCons.egg-info/PKG-INFO 2024-07-08 01:52:30.000000000 +0200 +++ new/scons-4.8.1/SCons.egg-info/PKG-INFO 2024-09-04 02:46:54.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: SCons -Version: 4.8.0 +Version: 4.8.1 Summary: Open Source next-generation build tool. Author-email: William Deegan <bill@baddogconsulting.com> License: MIT diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/pyproject.toml new/scons-4.8.1/pyproject.toml --- old/scons-4.8.0/pyproject.toml 2024-07-06 05:33:58.000000000 +0200 +++ new/scons-4.8.1/pyproject.toml 2024-07-22 03:13:08.000000000 +0200 @@ -52,6 +52,9 @@ include-package-data = true license-files = ["LICENSE"] +[tool.setuptools.dynamic] +version = {attr = "SCons.__version__"} + [tool.setuptools.packages.find] exclude = ["template"] namespaces = false diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/scons-time.1 new/scons-4.8.1/scons-time.1 --- old/scons-4.8.0/scons-time.1 2024-07-08 01:52:25.000000000 +0200 +++ new/scons-4.8.1/scons-time.1 2024-09-04 02:46:49.000000000 +0200 @@ -2,12 +2,12 @@ .\" Title: SCONS-TIME .\" Author: [see the "AUTHORS" section] .\" Generator: DocBook XSL Stylesheets v1.76.1 <http://docbook.sf.net/> -.\" Date: 07/07/2024 -.\" Manual: SCons 4.8.0 -.\" Source: SCons 4.8.0 +.\" Date: 09/03/2024 +.\" Manual: SCons 4.8.1 +.\" Source: SCons 4.8.1 .\" Language: English .\" -.TH "SCONS\-TIME" "1" "07/07/2024" "SCons 4\&.8\&.0" "SCons 4\&.8\&.0" +.TH "SCONS\-TIME" "1" "09/03/2024" "SCons 4\&.8\&.1" "SCons 4\&.8\&.1" .\" ----------------------------------------------------------------- .\" * Define some portability stuff .\" ----------------------------------------------------------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/scons.1 new/scons-4.8.1/scons.1 --- old/scons-4.8.0/scons.1 2024-07-08 01:52:28.000000000 +0200 +++ new/scons-4.8.1/scons.1 2024-09-04 02:46:52.000000000 +0200 @@ -2,12 +2,12 @@ .\" Title: SCONS .\" Author: The SCons Development Team .\" Generator: DocBook XSL Stylesheets v1.76.1 <http://docbook.sf.net/> -.\" Date: <pubdate>Released Sun, 07 Jul 2024 16:52:07 -0700</pubdate> -.\" Manual: SCons 4.8.0 -.\" Source: SCons 4.8.0 Version 4.8.0 +.\" Date: <pubdate>Released Tue, 03 Sep 2024 17:46:32 -0700</pubdate> +.\" Manual: SCons 4.8.1 +.\" Source: SCons 4.8.1 Version 4.8.1 .\" Language: English .\" -.TH "SCONS" "1" "<pubdate>Released Sun, 07 Jul 2024 16:52:07 -0700</pubdate>" "SCons 4\&.8\&.0 Version 4.8.0" "SCons 4\&.8\&.0" +.TH "SCONS" "1" "<pubdate>Released Tue, 03 Sep 2024 17:46:32 -0700</pubdate>" "SCons 4\&.8\&.1 Version 4.8.1" "SCons 4\&.8\&.1" .\" ----------------------------------------------------------------- .\" * Define some portability stuff .\" ----------------------------------------------------------------- @@ -2044,7 +2044,7 @@ Builder Methods .RE .RS 4 -Methods and Functions to do Things +Functions and Environment Methods .RE .RS 4 SConscript Variables @@ -8802,110 +8802,105 @@ for more information about defining your own Scanner objects and using the SourceFileScanner object\&. -.SS "Methods and Functions To Do Things" +.SS "SCons Functions and Environment Methods" .PP -In addition to Builder methods, -\fBscons\fR -provides a number of other + +SCons +provides a variety of construction environment -methods and global functions to manipulate the build configuration\&. Usually, a +methods and global functions to manipulate the build configuration\&. Often, a construction environment -method and global function with the same name both exist for convenience\&. In the following list, the global function is documented in this style: +method and a global function with the same name exist for convenience\&. In this section, both forms are shown if the function can be called in either way\&. The documentation style for these is as follows: .sp .if n \{\ .RS 4 .\} .nf -\fBFunction\fR(\fIarguments, [optional arguments]\fR) +\fBFunction\fR(\fIarguments, [optional arguments, \&.\&.\&.]\fR) # Global function +\fIenv\fR\&.Function(\fIarguments, [optional arguments, \&.\&.\&.]\fR) # Environment method .fi .if n \{\ .RE .\} .PP -and the +In these function signatures, arguments in brackets ([]) are optional, and ellipses (\&.\&.\&.) indicate possible repetition\&. Positional vs\&. keyword arguments are usually detailed in the following text, not in the signature itself\&. The +Python +positional\-only (/) and keyword\-only (*) markers are not used\&. +.PP +When the +Python +keyword=value +style is shown, it can have two meanings\&. If the keyword argument is known to the function, the value is the default for that argument if it is omitted\&. If the keyword is unknown to the function, some methods treat it as a +construction variable +assignment; otherwise an exception is raised for an unknown argument\&. +.PP +A global function and a same\-named construction environment -method looks like: +method have the same base functionality, with two key differences: .sp -.if n \{\ .RS 4 +.ie n \{\ +\h'-04' 1.\h'+01'\c .\} -.nf -\fIenv\fR\&.Function(\fIarguments, [optional arguments]\fR) -.fi -.if n \{\ -.RE +.el \{\ +.sp -1 +.IP " 1." 4.2 .\} -.PP -If the function can be called both ways, then both forms are listed\&. -.PP -The global function and same\-named -construction environment -method provide almost identical functionality, with a couple of exceptions\&. First, many of the -construction environment -methods affect only that -construction environment, while the global function has a global effect (or, alternatively, takes an additional positional argument to specify the affected -construction environment)\&. Second, where appropriate, calling the functionality through a -construction environment -will substitute -construction variables -into any supplied string arguments, while the global function, unless it takes a -construction environment -parameter, does not have the context of a + +Construction environment +methods that change the environment act on the environment instance from which they are called, while the corresponding global function acts on a special \(lqhidden\(rq construction environment -to pick variables from, and thus cannot perform substitutions\&. For example: +called the Default Environment\&. In some cases, the global function may take an initial argument giving the object to operate on\&. +.RE .sp -.if n \{\ .RS 4 +.ie n \{\ +\h'-04' 2.\h'+01'\c .\} -.nf -Default(\*(Aq$FOO\*(Aq) - -env = Environment(FOO=\*(Aqfoo\*(Aq) -env\&.Default(\*(Aq$FOO\*(Aq) -.fi -.if n \{\ -.RE +.el \{\ +.sp -1 +.IP " 2." 4.2 .\} -.PP -In the above example, the call to the global -\fBDefault\fR -function will add a target named -\fB$FOO\fR -to the list of default targets, while the call to the -\fBenv\&.Default\fR -construction environment -method will expand the value and add a target named -\fBfoo\fR -to the list of default targets\&. For more on +String\-valued arguments (including strings in list\-valued arguments) are subject to construction variable expansion by the environment method form; variable expansion is not immediately performed in the global function\&. For example, +\fBDefault(\*(Aq$MYTARGET\*(Aq)\fR +adds +\*(Aq$MYTARGET\*(Aq +to the list of default targets, while if the value in +\fIenv\fR +of +MYTARGET +is +\*(Aqmine\*(Aq, +\fBenv\&.Default(\*(Aq$MYTARGET\*(Aq\fR +adds +\*(Aqmine\*(Aq +to the default targets\&. For more details on construction variable expansion, see the Construction variables -section below\&. +section\&. +.RE .PP Global functions are automatically in scope inside SConscript -files\&. If you have custom +files\&. If your project adds +Python +modules that you include via the Python -code that you import into an +import +statement from an SConscript -file, such code will need to bring them into their own scope\&. You can do that by adding the following import to the +file, such code will need to add the functions to that module\(cqs global scope explicitly\&. You can do that by adding the following import to the Python module: -.sp -.if n \{\ -.RS 4 -.\} -.nf -from SCons\&.Script import * -.fi -.if n \{\ -.RE -.\} +\fBfrom SCons\&.Script import *\fR\&. .PP -Construction environment -methods and global functions provided by -\fBscons\fR -include: + +SCons +provides the following +construction environment +methods and global functions\&. The list can be augmented on a project basis using +\fBAddMethod\fR .PP \fBAction\fR(\fIaction, [output, [var, \&.\&.\&.]] [key=value, \&.\&.\&.]\fR), \fIenv\fR\&.Action(\fIaction, [output, [var, \&.\&.\&.]] [key=value, \&.\&.\&.]\fR) .RS 4 @@ -8975,16 +8970,18 @@ .\} .RE .PP -\fBAddOption\fR(\fIarguments\fR) +\fBAddOption\fR(\fIopt_str, \&.\&.\&., attr=value, \&.\&.\&.\fR) .RS 4 -Adds a local (project\-specific) command\-line option\&. -\fIarguments\fR -are the same as those supported by the -\fBadd_option\fR +Adds a local (project\-specific) command\-line option\&. One or more +\fIopt_str\fR +values are the strings representing how the option can be called, while the keyword arguments define attributes of the option\&. For the most part these are the same as for the +\fBOptionParser\&.add_option\fR method in the standard Python library module -optparse, with a few additional capabilities noted below\&. See the documentation for -optparse -for a thorough discussion of its option\-processing capabities\&. +optparse, but with a few additional capabilities noted below\&. See the +\m[blue]\fBoptparse documentation\fR\m[]\&\s-2\u[6]\d\s+2 +for a thorough discussion of its option\-processing capabities\&. All options added through +\fBAddOption\fR +are placed in a special "Local Options" option group\&. .sp In addition to the arguments and values supported by the optparse @@ -8993,7 +8990,9 @@ \fBAddOption\fR allows setting the \fInargs\fR -keyword value to a string consisting of a question mark (\*(Aq?\*(Aq) to indicate that the option argument for that option string is optional\&. If the option string is present on the command line but has no matching option argument, the value of the +keyword value to a string +\*(Aq?\*(Aq +(question mark) to indicate that the option argument for that option string may be omitted\&. If the option string is present on the command line but has no matching option argument, the value of the \fIconst\fR keyword argument is produced as the value of the option\&. If the option string is omitted from the command line, the value of the \fIdefault\fR @@ -10239,47 +10238,50 @@ .\} .RE .PP -\fBDefaultEnvironment\fR(\fI[**kwargs]\fR) +\fBDefaultEnvironment\fR(\fI[key=value, \&.\&.\&.]\fR) .RS 4 Instantiates and returns the global construction environment -object\&. This environment is used internally by SCons when it executes many of the global functions listed in this section (that is, those not called as methods of a specific -construction environment)\&. The -default environment -is a singleton: the keyword arguments are used only on the first call; on subsequent calls the already\-constructed object is returned and any keyword arguments are silently ignored\&. The -default environment -can still be modified after instantiation in the same way as any other -construction environment\&. The -default environment -is independent: modifying it has no effect on any other -construction environment -constructed by an +object\&. The +Default Environment +is used internally by +SCons +when executing a global function or the global form of a Builder method that requires access to a +construction environment\&. +.sp +On the first call, arguments are interpreted as for the \fBEnvironment\fR -or -\fBClone\fR -call\&. +function\&. The +Default Environment +is a singleton; subsequent calls to +\fBDefaultEnvironment\fR +return the already\-constructed object, and any keyword arguments are silently ignored\&. .sp -It is not mandatory to call -\fBDefaultEnvironment\fR: the +The +Default Environment +can be modified after instantiation, similar to other +construction environments, although some +construction environment +methods may be unavailable\&. Modifying the +Default Environment +has no effect on any other +construction environment, either existing or newly constructed\&. +.sp +It is not necessary to explicitly call +\fBDefaultEnvironment\fR\&. +SCons +instantiates the default environment -is instantiated automatically when the build phase begins if this function has not been called; however calling it explicitly gives the opportunity to affect and examine the contents of the -default environment\&. Instantiation happens even if no build instructions appar to use it, as there are internal uses\&. If there are no uses in the project +automatically when the build phase begins, if has not already been done\&. However, calling it explicitly provides the opportunity to affect and examine its contents\&. Instantiation occurs even if nothing in the build system appars to use it, due to internal uses\&. +.sp +If the project SConscript -files, a small performance gain may be seen by calling +files do not use global functions or Builders, a small performance gain may be achieved by calling \fBDefaultEnvironment\fR -with an empty tools list, thus avoiding that part of the initialization cost\&. This is mainly of interest in testing when +with an empty tools list (\fBDefaultEnvironment(tools=[])\fR)\&. This avoids the tool initialization cost for the +Default Environment, which is mainly of interest in the test suite where \fBscons\fR -is launched repeatedly in a short time period: -.sp -.if n \{\ -.RS 4 -.\} -.nf -DefaultEnvironment(tools=[]) -.fi -.if n \{\ -.RE -.\} +is launched repeatedly in a short time period\&. .RE .PP \fBDepends\fR(\fItarget, dependency\fR), \fIenv\fR\&.Depends(\fItarget, dependency\fR) @@ -10375,34 +10377,39 @@ Directory Nodes can be used anywhere you would supply a string as a directory name to a Builder method or function\&. Directory Nodes have attributes and methods that are useful in many situations; see manpage section "Filesystem Nodes" for more information\&. .RE .PP -\fIenv\fR\&.Dump(\fI[key], [format]\fR) +\fIenv\fR\&.Dump(\fI[key, \&.\&.\&.], [format=]\fR) .RS 4 Serializes construction variables +from the current +construction environment to a string\&. The method supports the following formats specified by -\fIformat\fR: +\fIformat\fR, which must be used a a keyword argument: .PP pretty .RS 4 -Returns a pretty printed representation of the environment (if -\fIformat\fR -is not specified, this is the default)\&. +Returns a pretty\-printed representation of the variables (this is the default)\&. The variables will be presented in +Python +dict form\&. .RE .PP json .RS 4 -Returns a JSON\-formatted string representation of the environment\&. +Returns a JSON\-formatted string representation of the variables\&. The variables will be presented as a JSON object literal, the JSON equivalent of a +Python +dict\&. .RE .sp -If +If no \fIkey\fR -is -\fBNone\fR -(the default) the entire dictionary of +is supplied, all the construction variables -is serialized\&. If supplied, it is taken as the name of a -construction variable -whose value is serialized\&. +are serialized\&. If one or more keys are supplied, only those keys and their values are serialized\&. +.sp + +\fIChanged in NEXT_VERSION\fR: More than one +\fIkey\fR +can be specified\&. The returned string always looks like a dict (or JSON equivalent); previously a single key serialized only the value, not the key with the value\&. .sp This SConstruct: .sp @@ -10410,20 +10417,25 @@ .RS 4 .\} .nf -env=Environment() +env = Environment() print(env\&.Dump(\*(AqCCCOM\*(Aq)) +print(env\&.Dump(\*(AqCC\*(Aq, \*(AqCCFLAGS\*(Aq, format=\*(Aqjson\*(Aq)) .fi .if n \{\ .RE .\} .sp -will print: +will print something like: .sp .if n \{\ .RS 4 .\} .nf -\*(Aq$CC \-c \-o $TARGET $CCFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS $SOURCES\*(Aq +{\*(AqCCCOM\*(Aq: \*(Aq$CC \-o $TARGET \-c $CFLAGS $CCFLAGS $_CCCOMCOM $SOURCES\*(Aq} +{ + "CC": "gcc", + "CCFLAGS": [] +} .fi .if n \{\ .RE @@ -10442,7 +10454,7 @@ .RE .\} .sp -will print: +will print something like: .sp .if n \{\ .RS 4 @@ -12884,7 +12896,7 @@ \fB\-Q\fR T}:T{ See - \&\s-2\u[6]\d\s+2 + \&\s-2\u[7]\d\s+2 T} T{ \fInum_jobs\fR @@ -13126,7 +13138,7 @@ .\} .RE .PP -\fBTool\fR(\fIname, [toolpath, **kwargs]\fR), \fIenv\fR\&.Tool(\fIname, [toolpath, **kwargs]\fR) +\fBTool\fR(\fIname, [toolpath, key=value, \&.\&.\&.]\fR), \fIenv\fR\&.Tool(\fIname, [toolpath, key=value, \&.\&.\&.]\fR) .RS 4 Locates the tool specification module \fIname\fR @@ -17454,7 +17466,7 @@ \fBLICENSE\fR .RS 4 The abbreviated name, preferably the SPDX code, of the license under which this project is released (GPL\-3\&.0, LGPL\-2\&.1, BSD\-2\-Clause etc\&.)\&. See -\m[blue]\fBhttp://www\&.opensource\&.org/licenses/alphabetical\fR\m[]\&\s-2\u[7]\d\s+2 +\m[blue]\fBhttp://www\&.opensource\&.org/licenses/alphabetical\fR\m[]\&\s-2\u[8]\d\s+2 for a list of license names and SPDX codes\&. .sp See the @@ -26165,7 +26177,7 @@ is limited on Windows and on WebAssembly platforms, see the notes in the Python documentation for -\m[blue]\fBos\&.chmod\fR\m[]\&\s-2\u[8]\d\s+2, which is the underlying function\&. +\m[blue]\fBos\&.chmod\fR\m[]\&\s-2\u[9]\d\s+2, which is the underlying function\&. .RE .PP \fBCopy\fR(\fIdest, src\fR) @@ -27671,7 +27683,7 @@ .RS 4 SCons source code - \m[blue]\fBon GitHub\fR\m[]\&\s-2\u[9]\d\s+2 + \m[blue]\fBon GitHub\fR\m[]\&\s-2\u[10]\d\s+2 .RE .RS 4 @@ -27724,6 +27736,11 @@ \%https://learn.microsoft.com/en-us/visualstudio/extensibility/internals/solut... .RE .IP " 6." 4 +optparse documentation +.RS 4 +\%https://docs.python.org/3/library/optparse.html +.RE +.IP " 7." 4 If \fIno_progress\fR is set via @@ -27734,17 +27751,17 @@ SCons has to start reading them before it can see the \fBSetOption\fR. -.IP " 7." 4 +.IP " 8." 4 http://www.opensource.org/licenses/alphabetical .RS 4 \%http://www.opensource.org/licenses/alphabetical .RE -.IP " 8." 4 +.IP " 9." 4 os.chmod .RS 4 \%https://docs.python.org/3/library/os.html#os.chmod .RE -.IP " 9." 4 +.IP "10." 4 on GitHub .RS 4 \%https://github.com/SCons/scons diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/sconsign.1 new/scons-4.8.1/sconsign.1 --- old/scons-4.8.0/sconsign.1 2024-07-08 01:52:28.000000000 +0200 +++ new/scons-4.8.1/sconsign.1 2024-09-04 02:46:52.000000000 +0200 @@ -2,12 +2,12 @@ .\" Title: SCONSIGN .\" Author: [see the "AUTHORS" section] .\" Generator: DocBook XSL Stylesheets v1.76.1 <http://docbook.sf.net/> -.\" Date: 07/07/2024 -.\" Manual: SCons 4.8.0 -.\" Source: SCons 4.8.0 +.\" Date: 09/03/2024 +.\" Manual: SCons 4.8.1 +.\" Source: SCons 4.8.1 .\" Language: English .\" -.TH "SCONSIGN" "1" "07/07/2024" "SCons 4\&.8\&.0" "SCons 4\&.8\&.0" +.TH "SCONSIGN" "1" "09/03/2024" "SCons 4\&.8\&.1" "SCons 4\&.8\&.1" .\" ----------------------------------------------------------------- .\" * Define some portability stuff .\" ----------------------------------------------------------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/scons-4.8.0/setup.py new/scons-4.8.1/setup.py --- old/scons-4.8.0/setup.py 2023-01-24 05:14:53.000000000 +0100 +++ new/scons-4.8.1/setup.py 2024-07-22 03:13:08.000000000 +0200 @@ -14,24 +14,16 @@ return fp.read() -def get_version(rel_path): - for line in read(rel_path).splitlines(): - if line.startswith('__version__'): - delim = '"' if '"' in line else "'" - return line.split(delim)[1] - else: - raise RuntimeError("Unable to find version string.") - - exclude = ['*Tests'] class build_py(build_py_orig): def find_package_modules(self, package, package_dir): - """ - Custom module to find package modules. - It will strip out any modules which match the glob patters in exclude above + """Custom module to find package modules. + + Will strip out any modules which match the glob patters in + *exclude* above """ modules = super().find_package_modules(package, package_dir) return [(pkg, mod, file, ) for (pkg, mod, file, ) in modules @@ -42,5 +34,4 @@ cmdclass={ 'build_py': build_py, }, - version=get_version('SCons/__init__.py'), -) \ No newline at end of file +)