supplier-meesho.webflow 1.0.0

package/GitRepos/black/tests/test_blackd.py

@@ -0,0 +1,166 @@
+import re
+from unittest.mock import patch
+
+from click.testing import CliRunner
+import pytest
+
+from tests.util import read_data, DETERMINISTIC_HEADER
+
+try:
+    import blackd
+    from aiohttp.test_utils import AioHTTPTestCase, unittest_run_loop
+    from aiohttp import web
+except ImportError:
+    has_blackd_deps = False
+else:
+    has_blackd_deps = True
+
+
+@pytest.mark.blackd
+class BlackDTestCase(AioHTTPTestCase):
+    def test_blackd_main(self) -> None:
+        with patch("blackd.web.run_app"):
+            result = CliRunner().invoke(blackd.main, [])
+            if result.exception is not None:
+                raise result.exception
+            self.assertEqual(result.exit_code, 0)
+
+    async def get_application(self) -> web.Application:
+        return blackd.make_app()
+
+    @unittest_run_loop
+    async def test_blackd_request_needs_formatting(self) -> None:
+        response = await self.client.post("/", data=b"print('hello world')")
+        self.assertEqual(response.status, 200)
+        self.assertEqual(response.charset, "utf8")
+        self.assertEqual(await response.read(), b'print("hello world")\n')
+
+    @unittest_run_loop
+    async def test_blackd_request_no_change(self) -> None:
+        response = await self.client.post("/", data=b'print("hello world")\n')
+        self.assertEqual(response.status, 204)
+        self.assertEqual(await response.read(), b"")
+
+    @unittest_run_loop
+    async def test_blackd_request_syntax_error(self) -> None:
+        response = await self.client.post("/", data=b"what even ( is")
+        self.assertEqual(response.status, 400)
+        content = await response.text()
+        self.assertTrue(
+            content.startswith("Cannot parse"),
+            msg=f"Expected error to start with 'Cannot parse', got {repr(content)}",
+        )
+
+    @unittest_run_loop
+    async def test_blackd_unsupported_version(self) -> None:
+        response = await self.client.post(
+            "/", data=b"what", headers={blackd.PROTOCOL_VERSION_HEADER: "2"}
+        )
+        self.assertEqual(response.status, 501)
+
+    @unittest_run_loop
+    async def test_blackd_supported_version(self) -> None:
+        response = await self.client.post(
+            "/", data=b"what", headers={blackd.PROTOCOL_VERSION_HEADER: "1"}
+        )
+        self.assertEqual(response.status, 200)
+
+    @unittest_run_loop
+    async def test_blackd_invalid_python_variant(self) -> None:
+        async def check(header_value: str, expected_status: int = 400) -> None:
+            response = await self.client.post(
+                "/", data=b"what", headers={blackd.PYTHON_VARIANT_HEADER: header_value}
+            )
+            self.assertEqual(response.status, expected_status)
+
+        await check("lol")
+        await check("ruby3.5")
+        await check("pyi3.6")
+        await check("py1.5")
+        await check("2.8")
+        await check("py2.8")
+        await check("3.0")
+        await check("pypy3.0")
+        await check("jython3.4")
+
+    @unittest_run_loop
+    async def test_blackd_pyi(self) -> None:
+        source, expected = read_data("stub.pyi")
+        response = await self.client.post(
+            "/", data=source, headers={blackd.PYTHON_VARIANT_HEADER: "pyi"}
+        )
+        self.assertEqual(response.status, 200)
+        self.assertEqual(await response.text(), expected)
+
+    @unittest_run_loop
+    async def test_blackd_diff(self) -> None:
+        diff_header = re.compile(
+            r"(In|Out)\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d\d\d\d \+\d\d\d\d"
+        )
+
+        source, _ = read_data("blackd_diff.py")
+        expected, _ = read_data("blackd_diff.diff")
+
+        response = await self.client.post(
+            "/", data=source, headers={blackd.DIFF_HEADER: "true"}
+        )
+        self.assertEqual(response.status, 200)
+
+        actual = await response.text()
+        actual = diff_header.sub(DETERMINISTIC_HEADER, actual)
+        self.assertEqual(actual, expected)
+
+    @unittest_run_loop
+    async def test_blackd_python_variant(self) -> None:
+        code = (
+            "def f(\n"
+            "    and_has_a_bunch_of,\n"
+            "    very_long_arguments_too,\n"
+            "    and_lots_of_them_as_well_lol,\n"
+            "    **and_very_long_keyword_arguments\n"
+            "):\n"
+            "    pass\n"
+        )
+
+        async def check(header_value: str, expected_status: int) -> None:
+            response = await self.client.post(
+                "/", data=code, headers={blackd.PYTHON_VARIANT_HEADER: header_value}
+            )
+            self.assertEqual(
+                response.status, expected_status, msg=await response.text()
+            )
+
+        await check("3.6", 200)
+        await check("py3.6", 200)
+        await check("3.6,3.7", 200)
+        await check("3.6,py3.7", 200)
+        await check("py36,py37", 200)
+        await check("36", 200)
+        await check("3.6.4", 200)
+
+        await check("2", 204)
+        await check("2.7", 204)
+        await check("py2.7", 204)
+        await check("3.4", 204)
+        await check("py3.4", 204)
+        await check("py34,py36", 204)
+        await check("34", 204)
+
+    @unittest_run_loop
+    async def test_blackd_line_length(self) -> None:
+        response = await self.client.post(
+            "/", data=b'print("hello")\n', headers={blackd.LINE_LENGTH_HEADER: "7"}
+        )
+        self.assertEqual(response.status, 200)
+
+    @unittest_run_loop
+    async def test_blackd_invalid_line_length(self) -> None:
+        response = await self.client.post(
+            "/", data=b'print("hello")\n', headers={blackd.LINE_LENGTH_HEADER: "NaN"}
+        )
+        self.assertEqual(response.status, 400)
+
+    @unittest_run_loop
+    async def test_blackd_response_black_version_header(self) -> None:
+        response = await self.client.post("/")
+        self.assertIsNotNone(response.headers.get(blackd.BLACK_VERSION_HEADER))

package/GitRepos/black/tests/test_format.py

@@ -0,0 +1,144 @@
+from unittest.mock import patch
+
+import black
+import pytest
+from parameterized import parameterized
+
+from tests.util import (
+    BlackBaseTestCase,
+    fs,
+    DEFAULT_MODE,
+    dump_to_stderr,
+    read_data,
+    THIS_DIR,
+)
+
+SIMPLE_CASES = [
+    "beginning_backslash",
+    "bracketmatch",
+    "class_blank_parentheses",
+    "class_methods_new_line",
+    "collections",
+    "comments",
+    "comments2",
+    "comments3",
+    "comments4",
+    "comments5",
+    "comments6",
+    "comments_non_breaking_space",
+    "comment_after_escaped_newline",
+    "composition",
+    "composition_no_trailing_comma",
+    "docstring",
+    "empty_lines",
+    "expression",
+    "fmtonoff",
+    "fmtonoff2",
+    "fmtonoff3",
+    "fmtonoff4",
+    "fmtskip",
+    "fmtskip2",
+    "fmtskip3",
+    "fmtskip4",
+    "fmtskip5",
+    "fstring",
+    "function",
+    "function2",
+    "function_trailing_comma",
+    "import_spacing",
+    "remove_parens",
+    "slices",
+    "string_prefixes",
+    "tricky_unicode_symbols",
+    "tupleassign",
+]
+
+SIMPLE_CASES_PY2 = [
+    "numeric_literals_py2",
+    "python2",
+    "python2_unicode_literals",
+]
+
+EXPERIMENTAL_STRING_PROCESSING_CASES = [
+    "cantfit",
+    "comments7",
+    "long_strings",
+    "long_strings__edge_case",
+    "long_strings__regression",
+    "percent_precedence",
+]
+
+
+SOURCES = [
+    "src/black/__init__.py",
+    "src/black/__main__.py",
+    "src/black/brackets.py",
+    "src/black/cache.py",
+    "src/black/comments.py",
+    "src/black/concurrency.py",
+    "src/black/const.py",
+    "src/black/debug.py",
+    "src/black/files.py",
+    "src/black/linegen.py",
+    "src/black/lines.py",
+    "src/black/mode.py",
+    "src/black/nodes.py",
+    "src/black/numerics.py",
+    "src/black/output.py",
+    "src/black/parsing.py",
+    "src/black/report.py",
+    "src/black/rusty.py",
+    "src/black/strings.py",
+    "src/black/trans.py",
+    "src/blackd/__init__.py",
+    "src/blib2to3/pygram.py",
+    "src/blib2to3/pytree.py",
+    "src/blib2to3/pgen2/conv.py",
+    "src/blib2to3/pgen2/driver.py",
+    "src/blib2to3/pgen2/grammar.py",
+    "src/blib2to3/pgen2/literals.py",
+    "src/blib2to3/pgen2/parse.py",
+    "src/blib2to3/pgen2/pgen.py",
+    "src/blib2to3/pgen2/tokenize.py",
+    "src/blib2to3/pgen2/token.py",
+    "setup.py",
+    "tests/test_black.py",
+    "tests/test_blackd.py",
+    "tests/test_format.py",
+    "tests/test_primer.py",
+    "tests/optional.py",
+    "tests/util.py",
+    "tests/conftest.py",
+]
+
+
+class TestSimpleFormat(BlackBaseTestCase):
+    @parameterized.expand(SIMPLE_CASES_PY2)
+    @pytest.mark.python2
+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_simple_format_py2(self, filename: str) -> None:
+        self.check_file(filename, DEFAULT_MODE)
+
+    @parameterized.expand(SIMPLE_CASES)
+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_simple_format(self, filename: str) -> None:
+        self.check_file(filename, DEFAULT_MODE)
+
+    @parameterized.expand(EXPERIMENTAL_STRING_PROCESSING_CASES)
+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_experimental_format(self, filename: str) -> None:
+        self.check_file(filename, black.Mode(experimental_string_processing=True))
+
+    @parameterized.expand(SOURCES)
+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_source_is_formatted(self, filename: str) -> None:
+        path = THIS_DIR.parent / filename
+        self.check_file(str(path), DEFAULT_MODE, data=False)
+
+    def check_file(self, filename: str, mode: black.Mode, *, data: bool = True) -> None:
+        source, expected = read_data(filename, data=data)
+        actual = fs(source, mode=mode)
+        self.assertFormatEqual(expected, actual)
+        if source != actual:
+            black.assert_equivalent(source, actual)
+            black.assert_stable(source, actual, mode)

package/GitRepos/black/tests/test_primer.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+
+import asyncio
+import sys
+import unittest
+from contextlib import contextmanager
+from copy import deepcopy
+from io import StringIO
+from os import getpid
+from pathlib import Path
+from platform import system
+from subprocess import CalledProcessError
+from tempfile import TemporaryDirectory, gettempdir
+from typing import Any, Callable, Generator, Iterator, Tuple
+from unittest.mock import Mock, patch
+
+from click.testing import CliRunner
+
+from black_primer import cli, lib
+
+
+EXPECTED_ANALYSIS_OUTPUT = """\
+-- primer results 📊 --
+
+68 / 69 succeeded (98.55%) ✅
+1 / 69 FAILED (1.45%) 💩
+ - 0 projects disabled by config
+ - 0 projects skipped due to Python version
+ - 0 skipped due to long checkout
+
+Failed projects:
+
+## black:
+ - Returned 69
+ - stdout:
+Black didn't work
+
+"""
+FAKE_PROJECT_CONFIG = {
+    "cli_arguments": ["--unittest"],
+    "expect_formatting_changes": False,
+    "git_clone_url": "https://github.com/psf/black.git",
+}
+
+
+@contextmanager
+def capture_stdout(command: Callable, *args: Any, **kwargs: Any) -> Generator:
+    old_stdout, sys.stdout = sys.stdout, StringIO()
+    try:
+        command(*args, **kwargs)
+        sys.stdout.seek(0)
+        yield sys.stdout.read()
+    finally:
+        sys.stdout = old_stdout
+
+
+@contextmanager
+def event_loop() -> Iterator[None]:
+    policy = asyncio.get_event_loop_policy()
+    loop = policy.new_event_loop()
+    asyncio.set_event_loop(loop)
+    if sys.platform == "win32":
+        asyncio.set_event_loop(asyncio.ProactorEventLoop())
+    try:
+        yield
+    finally:
+        loop.close()
+
+
+async def raise_subprocess_error_1(*args: Any, **kwargs: Any) -> None:
+    raise CalledProcessError(1, ["unittest", "error"], b"", b"")
+
+
+async def raise_subprocess_error_123(*args: Any, **kwargs: Any) -> None:
+    raise CalledProcessError(123, ["unittest", "error"], b"", b"")
+
+
+async def return_false(*args: Any, **kwargs: Any) -> bool:
+    return False
+
+
+async def return_subproccess_output(*args: Any, **kwargs: Any) -> Tuple[bytes, bytes]:
+    return (b"stdout", b"stderr")
+
+
+async def return_zero(*args: Any, **kwargs: Any) -> int:
+    return 0
+
+
+class PrimerLibTests(unittest.TestCase):
+    def test_analyze_results(self) -> None:
+        fake_results = lib.Results(
+            {
+                "disabled": 0,
+                "failed": 1,
+                "skipped_long_checkout": 0,
+                "success": 68,
+                "wrong_py_ver": 0,
+            },
+            {"black": CalledProcessError(69, ["black"], b"Black didn't work", b"")},
+        )
+        with capture_stdout(lib.analyze_results, 69, fake_results) as analyze_stdout:
+            self.assertEqual(EXPECTED_ANALYSIS_OUTPUT, analyze_stdout)
+
+    @event_loop()
+    def test_black_run(self) -> None:
+        """Pretend to run Black to ensure we cater for all scenarios"""
+        loop = asyncio.get_event_loop()
+        repo_path = Path(gettempdir())
+        project_config = deepcopy(FAKE_PROJECT_CONFIG)
+        results = lib.Results({"failed": 0, "success": 0}, {})
+
+        # Test a successful Black run
+        with patch("black_primer.lib._gen_check_output", return_subproccess_output):
+            loop.run_until_complete(lib.black_run(repo_path, project_config, results))
+        self.assertEqual(1, results.stats["success"])
+        self.assertFalse(results.failed_projects)
+
+        # Test a fail based on expecting formatting changes but not getting any
+        project_config["expect_formatting_changes"] = True
+        results = lib.Results({"failed": 0, "success": 0}, {})
+        with patch("black_primer.lib._gen_check_output", return_subproccess_output):
+            loop.run_until_complete(lib.black_run(repo_path, project_config, results))
+        self.assertEqual(1, results.stats["failed"])
+        self.assertTrue(results.failed_projects)
+
+        # Test a fail based on returning 1 and not expecting formatting changes
+        project_config["expect_formatting_changes"] = False
+        results = lib.Results({"failed": 0, "success": 0}, {})
+        with patch("black_primer.lib._gen_check_output", raise_subprocess_error_1):
+            loop.run_until_complete(lib.black_run(repo_path, project_config, results))
+        self.assertEqual(1, results.stats["failed"])
+        self.assertTrue(results.failed_projects)
+
+        # Test a formatting error based on returning 123
+        with patch("black_primer.lib._gen_check_output", raise_subprocess_error_123):
+            loop.run_until_complete(lib.black_run(repo_path, project_config, results))
+        self.assertEqual(2, results.stats["failed"])
+
+    @event_loop()
+    def test_gen_check_output(self) -> None:
+        loop = asyncio.get_event_loop()
+        stdout, stderr = loop.run_until_complete(
+            lib._gen_check_output([lib.BLACK_BINARY, "--help"])
+        )
+        self.assertTrue("The uncompromising code formatter" in stdout.decode("utf8"))
+        self.assertEqual(None, stderr)
+
+        # TODO: Add a test to see failure works on Windows
+        if lib.WINDOWS:
+            return
+
+        false_bin = "/usr/bin/false" if system() == "Darwin" else "/bin/false"
+        with self.assertRaises(CalledProcessError):
+            loop.run_until_complete(lib._gen_check_output([false_bin]))
+
+        with self.assertRaises(asyncio.TimeoutError):
+            loop.run_until_complete(
+                lib._gen_check_output(["/bin/sleep", "2"], timeout=0.1)
+            )
+
+    @event_loop()
+    def test_git_checkout_or_rebase(self) -> None:
+        loop = asyncio.get_event_loop()
+        project_config = deepcopy(FAKE_PROJECT_CONFIG)
+        work_path = Path(gettempdir())
+
+        expected_repo_path = work_path / "black"
+        with patch("black_primer.lib._gen_check_output", return_subproccess_output):
+            returned_repo_path = loop.run_until_complete(
+                lib.git_checkout_or_rebase(work_path, project_config)
+            )
+        self.assertEqual(expected_repo_path, returned_repo_path)
+
+    @patch("sys.stdout", new_callable=StringIO)
+    @event_loop()
+    def test_process_queue(self, mock_stdout: Mock) -> None:
+        loop = asyncio.get_event_loop()
+        config_path = Path(lib.__file__).parent / "primer.json"
+        with patch("black_primer.lib.git_checkout_or_rebase", return_false):
+            with TemporaryDirectory() as td:
+                return_val = loop.run_until_complete(
+                    lib.process_queue(str(config_path), td, 2)
+                )
+                self.assertEqual(0, return_val)
+
+
+class PrimerCLITests(unittest.TestCase):
+    @event_loop()
+    def test_async_main(self) -> None:
+        loop = asyncio.get_event_loop()
+        work_dir = Path(gettempdir()) / f"primer_ut_{getpid()}"
+        args = {
+            "config": "/config",
+            "debug": False,
+            "keep": False,
+            "long_checkouts": False,
+            "rebase": False,
+            "workdir": str(work_dir),
+            "workers": 69,
+            "no_diff": False,
+        }
+        with patch("black_primer.cli.lib.process_queue", return_zero):
+            return_val = loop.run_until_complete(cli.async_main(**args))
+            self.assertEqual(0, return_val)
+
+    def test_handle_debug(self) -> None:
+        self.assertTrue(cli._handle_debug(None, None, True))
+
+    def test_help_output(self) -> None:
+        runner = CliRunner()
+        result = runner.invoke(cli.main, ["--help"])
+        self.assertEqual(result.exit_code, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/GitRepos/black/tests/util.py

@@ -0,0 +1,74 @@
+import os
+import unittest
+from pathlib import Path
+from typing import List, Tuple, Any
+from functools import partial
+
+import black
+from black.output import out, err
+from black.debug import DebugVisitor
+
+THIS_DIR = Path(__file__).parent
+PROJECT_ROOT = THIS_DIR.parent
+EMPTY_LINE = "# EMPTY LINE WITH WHITESPACE" + " (this comment will be removed)"
+DETERMINISTIC_HEADER = "[Deterministic header]"
+
+
+DEFAULT_MODE = black.Mode()
+ff = partial(black.format_file_in_place, mode=DEFAULT_MODE, fast=True)
+fs = partial(black.format_str, mode=DEFAULT_MODE)
+
+
+def dump_to_stderr(*output: str) -> str:
+    return "\n" + "\n".join(output) + "\n"
+
+
+class BlackBaseTestCase(unittest.TestCase):
+    maxDiff = None
+    _diffThreshold = 2 ** 20
+
+    def assertFormatEqual(self, expected: str, actual: str) -> None:
+        if actual != expected and not os.environ.get("SKIP_AST_PRINT"):
+            bdv: DebugVisitor[Any]
+            out("Expected tree:", fg="green")
+            try:
+                exp_node = black.lib2to3_parse(expected)
+                bdv = DebugVisitor()
+                list(bdv.visit(exp_node))
+            except Exception as ve:
+                err(str(ve))
+            out("Actual tree:", fg="red")
+            try:
+                exp_node = black.lib2to3_parse(actual)
+                bdv = DebugVisitor()
+                list(bdv.visit(exp_node))
+            except Exception as ve:
+                err(str(ve))
+        self.assertMultiLineEqual(expected, actual)
+
+
+def read_data(name: str, data: bool = True) -> Tuple[str, str]:
+    """read_data('test_name') -> 'input', 'output'"""
+    if not name.endswith((".py", ".pyi", ".out", ".diff")):
+        name += ".py"
+    base_dir = THIS_DIR / "data" if data else PROJECT_ROOT
+    return read_data_from_file(base_dir / name)
+
+
+def read_data_from_file(file_name: Path) -> Tuple[str, str]:
+    with open(file_name, "r", encoding="utf8") as test:
+        lines = test.readlines()
+    _input: List[str] = []
+    _output: List[str] = []
+    result = _input
+    for line in lines:
+        line = line.replace(EMPTY_LINE, "")
+        if line.rstrip() == "# output":
+            result = _output
+            continue
+
+        result.append(line)
+    if _input and not _output:
+        # If there's no output marker, treat the entire file as already pre-formatted.
+        _output = _input[:]
+    return "".join(_input).strip() + "\n", "".join(_output).strip() + "\n"

package/GitRepos/black/tox.ini

@@ -0,0 +1,28 @@
+[tox]
+envlist = py{36,37,38,39},fuzz
+
+[testenv]
+setenv = PYTHONPATH = {toxinidir}/src
+skip_install = True
+deps =
+    -r{toxinidir}/test_requirements.txt
+commands =
+    pip install -e .[d]
+    coverage erase
+    pytest tests --run-optional no_python2 --numprocesses auto --cov {posargs}
+    pip install -e .[d,python2]
+    pytest tests --run-optional python2 --numprocesses auto --cov --cov-append {posargs}
+    coverage report
+
+[testenv:fuzz]
+skip_install = True
+deps =
+    -r{toxinidir}/test_requirements.txt
+    hypothesmith
+    lark-parser < 0.10.0
+; lark-parser's version is set due to a bug in hypothesis. Once it solved, that would be fixed.
+commands =
+    pip install -e .[d]
+    coverage erase
+    coverage run fuzz.py
+    coverage report

package/GitRepos/danger-static_analyzer_comments/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Rubocop" enabled="false" level="WARNING" enabled_by_default="false" />
+  </profile>
+</component>

package/GitRepos/danger-static_analyzer_comments/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/danger-static_analyzer_comments.iml" filepath="$PROJECT_DIR$/danger-static_analyzer_comments.iml" />
+    </modules>
+  </component>
+</project>

package/GitRepos/danger-static_analyzer_comments/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec