@cloudbase/manager-node 4.3.3 → 4.3.4

package/.yarn/unplugged/node-gyp-npm-11.2.0-36aeb0fa50/node_modules/node-gyp/gyp/pylib/gyp/common_test.py

@@ -1,173 +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 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_GetCrossCompilerPredefines(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):
-            with patch("subprocess.run") as mock_run:
-                mock_process = MagicMock()
-                mock_process.returncode = 0
-                mock_process.stdout = TestGetFlavor.MockCommunicate(defines_stdout)
-                mock_run.return_value = mock_process
-                expected_input = "temp.c" if sys.platform == "win32" else "/dev/null"
-                with patch.dict(os.environ, env):
-                    defines = gyp.common.GetCrossCompilerPredefines()
-                    flavor = gyp.common.GetFlavor({})
-                if env.get("CC_target"):
-                    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]
-
-        [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/.yarn/unplugged/node-gyp-npm-11.2.0-36aeb0fa50/node_modules/node-gyp/gyp/pylib/gyp/easy_xml.py

@@ -1,169 +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/.yarn/unplugged/node-gyp-npm-11.2.0-36aeb0fa50/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/.yarn/unplugged/node-gyp-npm-11.2.0-36aeb0fa50/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:]))