@pnpm/exe 11.10.0 → 11.12.0

package/dist/node_modules/node-gyp/gyp/pylib/gyp/common_test.py

@@ -1,186 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2012 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Unit tests for the common.py file."""
-
-import os
-import subprocess
-import sys
-import unittest
-from unittest.mock import MagicMock, patch
-
-import gyp.common
-
-
-class TestTopologicallySorted(unittest.TestCase):
-    def test_Valid(self):
-        """Test that sorting works on a valid graph with one possible order."""
-        graph = {
-            "a": ["b", "c"],
-            "b": [],
-            "c": ["d"],
-            "d": ["b"],
-        }
-
-        def GetEdge(node):
-            return tuple(graph[node])
-
-        assert gyp.common.TopologicallySorted(graph.keys(), GetEdge) == [
-            "a",
-            "c",
-            "d",
-            "b",
-        ]
-
-    def test_Cycle(self):
-        """Test that an exception is thrown on a cyclic graph."""
-        graph = {
-            "a": ["b"],
-            "b": ["c"],
-            "c": ["d"],
-            "d": ["a"],
-        }
-
-        def GetEdge(node):
-            return tuple(graph[node])
-
-        self.assertRaises(
-            gyp.common.CycleError, gyp.common.TopologicallySorted, graph.keys(), GetEdge
-        )
-
-
-class TestGetFlavor(unittest.TestCase):
-    """Test that gyp.common.GetFlavor works as intended"""
-
-    original_platform = ""
-
-    def setUp(self):
-        self.original_platform = sys.platform
-
-    def tearDown(self):
-        sys.platform = self.original_platform
-
-    def assertFlavor(self, expected, argument, param):
-        sys.platform = argument
-        assert expected == gyp.common.GetFlavor(param)
-
-    def test_platform_default(self):
-        self.assertFlavor("freebsd", "freebsd9", {})
-        self.assertFlavor("freebsd", "freebsd10", {})
-        self.assertFlavor("openbsd", "openbsd5", {})
-        self.assertFlavor("solaris", "sunos5", {})
-        self.assertFlavor("solaris", "sunos", {})
-        self.assertFlavor("linux", "linux2", {})
-        self.assertFlavor("linux", "linux3", {})
-        self.assertFlavor("linux", "linux", {})
-
-    def test_param(self):
-        self.assertFlavor("foobar", "linux2", {"flavor": "foobar"})
-
-    class MockCommunicate:
-        def __init__(self, stdout):
-            self.stdout = stdout
-
-        def decode(self, encoding):
-            return self.stdout
-
-    @patch("os.close")
-    @patch("os.unlink")
-    @patch("tempfile.mkstemp")
-    def test_GetCompilerPredefines(self, mock_mkstemp, mock_unlink, mock_close):
-        mock_close.return_value = None
-        mock_unlink.return_value = None
-        mock_mkstemp.return_value = (0, "temp.c")
-
-        def mock_run(env, defines_stdout, expected_cmd, throws=False):
-            with patch("subprocess.run") as mock_run:
-                expected_input = "temp.c" if sys.platform == "win32" else "/dev/null"
-                if throws:
-                    mock_run.side_effect = subprocess.CalledProcessError(
-                        returncode=1,
-                        cmd=[*expected_cmd, "-dM", "-E", "-x", "c", expected_input],
-                    )
-                else:
-                    mock_process = MagicMock()
-                    mock_process.returncode = 0
-                    mock_process.stdout = TestGetFlavor.MockCommunicate(defines_stdout)
-                    mock_run.return_value = mock_process
-                with patch.dict(os.environ, env):
-                    try:
-                        defines = gyp.common.GetCompilerPredefines()
-                    except Exception as e:
-                        self.fail(f"GetCompilerPredefines raised an exception: {e}")
-                    flavor = gyp.common.GetFlavor({})
-                if env.get("CC_target") or env.get("CC"):
-                    mock_run.assert_called_with(
-                        [*expected_cmd, "-dM", "-E", "-x", "c", expected_input],
-                        shell=sys.platform == "win32",
-                        capture_output=True,
-                        check=True,
-                    )
-                return [defines, flavor]
-
-        [defines0, _] = mock_run({"CC": "cl.exe"}, "", ["cl.exe"], True)
-        assert defines0 == {}
-
-        [defines1, _] = mock_run({}, "", [])
-        assert defines1 == {}
-
-        [defines2, flavor2] = mock_run(
-            {"CC_target": "/opt/wasi-sdk/bin/clang"},
-            "#define __wasm__ 1\n#define __wasi__ 1\n",
-            ["/opt/wasi-sdk/bin/clang"],
-        )
-        assert defines2 == {"__wasm__": "1", "__wasi__": "1"}
-        assert flavor2 == "wasi"
-
-        [defines3, flavor3] = mock_run(
-            {"CC_target": "/opt/wasi-sdk/bin/clang --target=wasm32"},
-            "#define __wasm__ 1\n",
-            ["/opt/wasi-sdk/bin/clang", "--target=wasm32"],
-        )
-        assert defines3 == {"__wasm__": "1"}
-        assert flavor3 == "wasm"
-
-        [defines4, flavor4] = mock_run(
-            {"CC_target": "/emsdk/upstream/emscripten/emcc"},
-            "#define __EMSCRIPTEN__ 1\n",
-            ["/emsdk/upstream/emscripten/emcc"],
-        )
-        assert defines4 == {"__EMSCRIPTEN__": "1"}
-        assert flavor4 == "emscripten"
-
-        # Test path which include white space
-        [defines5, flavor5] = mock_run(
-            {
-                "CC_target": '"/Users/Toyo Li/wasi-sdk/bin/clang" -O3',
-                "CFLAGS": "--target=wasm32-wasi-threads -pthread",
-            },
-            "#define __wasm__ 1\n#define __wasi__ 1\n#define _REENTRANT 1\n",
-            [
-                "/Users/Toyo Li/wasi-sdk/bin/clang",
-                "-O3",
-                "--target=wasm32-wasi-threads",
-                "-pthread",
-            ],
-        )
-        assert defines5 == {"__wasm__": "1", "__wasi__": "1", "_REENTRANT": "1"}
-        assert flavor5 == "wasi"
-
-        original_sep = os.sep
-        os.sep = "\\"
-        [defines6, flavor6] = mock_run(
-            {"CC_target": '"C:\\Program Files\\wasi-sdk\\clang.exe"'},
-            "#define __wasm__ 1\n#define __wasi__ 1\n",
-            ["C:/Program Files/wasi-sdk/clang.exe"],
-        )
-        os.sep = original_sep
-        assert defines6 == {"__wasm__": "1", "__wasi__": "1"}
-        assert flavor6 == "wasi"
-
-
-if __name__ == "__main__":
-    unittest.main()

package/dist/node_modules/node-gyp/gyp/pylib/gyp/easy_xml.py

@@ -1,170 +0,0 @@
-# Copyright (c) 2011 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-import locale
-import os
-import re
-import sys
-from functools import reduce
-
-
-def XmlToString(content, encoding="utf-8", pretty=False):
-    """Writes the XML content to disk, touching the file only if it has changed.
-
-    Visual Studio files have a lot of pre-defined structures.  This function makes
-    it easy to represent these structures as Python data structures, instead of
-    having to create a lot of function calls.
-
-    Each XML element of the content is represented as a list composed of:
-    1. The name of the element, a string,
-    2. The attributes of the element, a dictionary (optional), and
-    3+. The content of the element, if any.  Strings are simple text nodes and
-        lists are child elements.
-
-    Example 1:
-        <test/>
-    becomes
-        ['test']
-
-    Example 2:
-        <myelement a='value1' b='value2'>
-           <childtype>This is</childtype>
-           <childtype>it!</childtype>
-        </myelement>
-
-    becomes
-        ['myelement', {'a':'value1', 'b':'value2'},
-           ['childtype', 'This is'],
-           ['childtype', 'it!'],
-        ]
-
-    Args:
-      content:  The structured content to be converted.
-      encoding: The encoding to report on the first XML line.
-      pretty: True if we want pretty printing with indents and new lines.
-
-    Returns:
-      The XML content as a string.
-    """
-    # We create a huge list of all the elements of the file.
-    xml_parts = ['<?xml version="1.0" encoding="%s"?>' % encoding]
-    if pretty:
-        xml_parts.append("\n")
-    _ConstructContentList(xml_parts, content, pretty)
-
-    # Convert it to a string
-    return "".join(xml_parts)
-
-
-def _ConstructContentList(xml_parts, specification, pretty, level=0):
-    """Appends the XML parts corresponding to the specification.
-
-    Args:
-      xml_parts: A list of XML parts to be appended to.
-      specification:  The specification of the element.  See EasyXml docs.
-      pretty: True if we want pretty printing with indents and new lines.
-      level: Indentation level.
-    """
-    # The first item in a specification is the name of the element.
-    if pretty:
-        indentation = "  " * level
-        new_line = "\n"
-    else:
-        indentation = ""
-        new_line = ""
-    name = specification[0]
-    if not isinstance(name, str):
-        raise Exception(
-            "The first item of an EasyXml specification should be "
-            "a string.  Specification was " + str(specification)
-        )
-    xml_parts.append(indentation + "<" + name)
-
-    # Optionally in second position is a dictionary of the attributes.
-    rest = specification[1:]
-    if rest and isinstance(rest[0], dict):
-        for at, val in sorted(rest[0].items()):
-            xml_parts.append(f' {at}="{_XmlEscape(val, attr=True)}"')
-        rest = rest[1:]
-    if rest:
-        xml_parts.append(">")
-        all_strings = reduce(lambda x, y: x and isinstance(y, str), rest, True)
-        multi_line = not all_strings
-        if multi_line and new_line:
-            xml_parts.append(new_line)
-        for child_spec in rest:
-            # If it's a string, append a text node.
-            # Otherwise recurse over that child definition
-            if isinstance(child_spec, str):
-                xml_parts.append(_XmlEscape(child_spec))
-            else:
-                _ConstructContentList(xml_parts, child_spec, pretty, level + 1)
-        if multi_line and indentation:
-            xml_parts.append(indentation)
-        xml_parts.append(f"</{name}>{new_line}")
-    else:
-        xml_parts.append("/>%s" % new_line)
-
-
-def WriteXmlIfChanged(
-    content, path, encoding="utf-8", pretty=False, win32=(sys.platform == "win32")
-):
-    """Writes the XML content to disk, touching the file only if it has changed.
-
-    Args:
-      content:  The structured content to be written.
-      path: Location of the file.
-      encoding: The encoding to report on the first line of the XML file.
-      pretty: True if we want pretty printing with indents and new lines.
-    """
-    xml_string = XmlToString(content, encoding, pretty)
-    if win32 and os.linesep != "\r\n":
-        xml_string = xml_string.replace("\n", "\r\n")
-
-    try:  # getdefaultlocale() was removed in Python 3.11
-        default_encoding = locale.getdefaultlocale()[1]
-    except AttributeError:
-        default_encoding = locale.getencoding()
-
-    if default_encoding and default_encoding.upper() != encoding.upper():
-        xml_string = xml_string.encode(encoding)
-
-    # Get the old content
-    try:
-        with open(path) as file:
-            existing = file.read()
-    except OSError:
-        existing = None
-
-    # It has changed, write it
-    if existing != xml_string:
-        with open(path, "wb") as file:
-            file.write(xml_string)
-
-
-_xml_escape_map = {
-    '"': "&quot;",
-    "'": "&apos;",
-    "<": "&lt;",
-    ">": "&gt;",
-    "&": "&amp;",
-    "\n": "&#xA;",
-    "\r": "&#xD;",
-}
-
-
-_xml_escape_re = re.compile("(%s)" % "|".join(map(re.escape, _xml_escape_map.keys())))
-
-
-def _XmlEscape(value, attr=False):
-    """Escape a string for inclusion in XML."""
-
-    def replace(match):
-        m = match.string[match.start() : match.end()]
-        # don't replace single quotes in attrs
-        if attr and m == "'":
-            return m
-        return _xml_escape_map[m]
-
-    return _xml_escape_re.sub(replace, value)

package/dist/node_modules/node-gyp/gyp/pylib/gyp/easy_xml_test.py

@@ -1,113 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2011 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Unit tests for the easy_xml.py file."""
-
-import unittest
-from io import StringIO
-
-from gyp import easy_xml
-
-
-class TestSequenceFunctions(unittest.TestCase):
-    def setUp(self):
-        self.stderr = StringIO()
-
-    def test_EasyXml_simple(self):
-        self.assertEqual(
-            easy_xml.XmlToString(["test"]),
-            '<?xml version="1.0" encoding="utf-8"?><test/>',
-        )
-
-        self.assertEqual(
-            easy_xml.XmlToString(["test"], encoding="Windows-1252"),
-            '<?xml version="1.0" encoding="Windows-1252"?><test/>',
-        )
-
-    def test_EasyXml_simple_with_attributes(self):
-        self.assertEqual(
-            easy_xml.XmlToString(["test2", {"a": "value1", "b": "value2"}]),
-            '<?xml version="1.0" encoding="utf-8"?><test2 a="value1" b="value2"/>',
-        )
-
-    def test_EasyXml_escaping(self):
-        original = "<test>'\"\r&\nfoo"
-        converted = "&lt;test&gt;'&quot;&#xD;&amp;&#xA;foo"
-        converted_apos = converted.replace("'", "&apos;")
-        self.assertEqual(
-            easy_xml.XmlToString(["test3", {"a": original}, original]),
-            '<?xml version="1.0" encoding="utf-8"?><test3 a="%s">%s</test3>'
-            % (converted, converted_apos),
-        )
-
-    def test_EasyXml_pretty(self):
-        self.assertEqual(
-            easy_xml.XmlToString(
-                ["test3", ["GrandParent", ["Parent1", ["Child"]], ["Parent2"]]],
-                pretty=True,
-            ),
-            '<?xml version="1.0" encoding="utf-8"?>\n'
-            "<test3>\n"
-            "  <GrandParent>\n"
-            "    <Parent1>\n"
-            "      <Child/>\n"
-            "    </Parent1>\n"
-            "    <Parent2/>\n"
-            "  </GrandParent>\n"
-            "</test3>\n",
-        )
-
-    def test_EasyXml_complex(self):
-        # We want to create:
-        target = (
-            '<?xml version="1.0" encoding="utf-8"?>'
-            "<Project>"
-            '<PropertyGroup Label="Globals">'
-            "<ProjectGuid>{D2250C20-3A94-4FB9-AF73-11BC5B73884B}</ProjectGuid>"
-            "<Keyword>Win32Proj</Keyword>"
-            "<RootNamespace>automated_ui_tests</RootNamespace>"
-            "</PropertyGroup>"
-            '<Import Project="$(VCTargetsPath)\\Microsoft.Cpp.props"/>'
-            "<PropertyGroup "
-            "Condition=\"'$(Configuration)|$(Platform)'=="
-            '\'Debug|Win32\'" Label="Configuration">'
-            "<ConfigurationType>Application</ConfigurationType>"
-            "<CharacterSet>Unicode</CharacterSet>"
-            "<SpectreMitigation>SpectreLoadCF</SpectreMitigation>"
-            "<VCToolsVersion>14.36.32532</VCToolsVersion>"
-            "</PropertyGroup>"
-            "</Project>"
-        )
-
-        xml = easy_xml.XmlToString(
-            [
-                "Project",
-                [
-                    "PropertyGroup",
-                    {"Label": "Globals"},
-                    ["ProjectGuid", "{D2250C20-3A94-4FB9-AF73-11BC5B73884B}"],
-                    ["Keyword", "Win32Proj"],
-                    ["RootNamespace", "automated_ui_tests"],
-                ],
-                ["Import", {"Project": "$(VCTargetsPath)\\Microsoft.Cpp.props"}],
-                [
-                    "PropertyGroup",
-                    {
-                        "Condition": "'$(Configuration)|$(Platform)'=='Debug|Win32'",
-                        "Label": "Configuration",
-                    },
-                    ["ConfigurationType", "Application"],
-                    ["CharacterSet", "Unicode"],
-                    ["SpectreMitigation", "SpectreLoadCF"],
-                    ["VCToolsVersion", "14.36.32532"],
-                ],
-            ]
-        )
-        self.assertEqual(xml, target)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/dist/node_modules/node-gyp/gyp/pylib/gyp/flock_tool.py

@@ -1,55 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2011 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""These functions are executed via gyp-flock-tool when using the Makefile
-generator.  Used on systems that don't have a built-in flock."""
-
-import fcntl
-import os
-import struct
-import subprocess
-import sys
-
-
-def main(args):
-    executor = FlockTool()
-    executor.Dispatch(args)
-
-
-class FlockTool:
-    """This class emulates the 'flock' command."""
-
-    def Dispatch(self, args):
-        """Dispatches a string command to a method."""
-        if len(args) < 1:
-            raise Exception("Not enough arguments")
-
-        method = "Exec%s" % self._CommandifyName(args[0])
-        getattr(self, method)(*args[1:])
-
-    def _CommandifyName(self, name_string):
-        """Transforms a tool name like copy-info-plist to CopyInfoPlist"""
-        return name_string.title().replace("-", "")
-
-    def ExecFlock(self, lockfile, *cmd_list):
-        """Emulates the most basic behavior of Linux's flock(1)."""
-        # Rely on exception handling to report errors.
-        # Note that the stock python on SunOS has a bug
-        # where fcntl.flock(fd, LOCK_EX) always fails
-        # with EBADF, that's why we use this F_SETLK
-        # hack instead.
-        fd = os.open(lockfile, os.O_WRONLY | os.O_NOCTTY | os.O_CREAT, 0o666)
-        if sys.platform.startswith("aix") or sys.platform == "os400":
-            # Python on AIX is compiled with LARGEFILE support, which changes the
-            # struct size.
-            op = struct.pack("hhIllqq", fcntl.F_WRLCK, 0, 0, 0, 0, 0, 0)
-        else:
-            op = struct.pack("hhllhhl", fcntl.F_WRLCK, 0, 0, 0, 0, 0, 0)
-        fcntl.fcntl(fd, fcntl.F_SETLK, op)
-        return subprocess.call(cmd_list)
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))