@pnpm/exe 11.0.0-dev.1005 → 11.0.0-rc.0

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

@@ -0,0 +1,186 @@
+#!/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

@@ -0,0 +1,170 @@
+# 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

@@ -0,0 +1,113 @@
+#!/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

@@ -0,0 +1,55 @@
+#!/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:]))