Reset migration script to template

This resets cookiecutter/migrate.py to match .github/cookiecutter-migrate.template.py,
removing all previous migration steps to prepare for new migrations.

Signed-off-by: Mathias L. Baumann <[email protected]>

Author: Marenz

cookiecutter/migrate.py

@@ -22,205 +22,20 @@
 
 import hashlib
 import os
-import re
 import subprocess
 import tempfile
 from pathlib import Path
-from typing import Final, SupportsIndex
+from typing import SupportsIndex
 
 
 def main() -> None:
     """Run the migration steps."""
     # Add a separation line like this one after each migration step.
     print("=" * 72)
-    migrate_filterwarnings(Path("pyproject.toml"))
-    print(
-        "Renaming the deprecated mkdocstrings `import` to `inventories` in `mkdocs.yml`..."
-    )
-    print("=" * 72)
-    replace_file_contents_atomically(
-        "mkdocs.yml", "          import:", "          inventories:"
-    )
-    print("=" * 72)
-    print("Fixing wrongly located `paths` keys in mkdocs.yml...")
-    migrate_mkdocs_yaml(Path("mkdocs.yml"))
-    print("=" * 72)
     print("Migration script finished. Remember to follow any manual instructions.")
     print("=" * 72)
 
 
-# pylint: disable-next=too-many-locals,too-many-statements,too-many-branches
-def migrate_filterwarnings(path: Path) -> None:
-    """Migrate the filterwarnings configuration in pyproject.toml files."""
-    print(f"Migrating from pytest addopts to filterwarnings in {path}...")
-    # Patterns to identify and clean existing addopts flags
-    addopts_re: Final = re.compile(r'^(\s*)addopts\s*=\s*"(.*)"')
-    filterwarnings_re: Final = re.compile(r"^(\s*)filterwarnings\s*=\s*(.*)")
-    w_flag_re: Final = re.compile(r"^-W=?(.*)$")
-    unwanted_flags: Final = {
-        "-W=all",
-        "-Werror",
-        "-Wdefault::DeprecationWarning",
-        "-Wdefault::PendingDeprecationWarning",
-    }
-
-    text = path.read_text(encoding="utf-8")
-    lines = text.splitlines(keepends=True)
-    new_lines: list[str] = []
-    modified = False
-    addopts_found = False
-    has_filterwarnings = False
-    has_w_flags = False
-    w_flags: list[str] = []
-
-    for line in lines:
-        filterwarnings_match = filterwarnings_re.match(line)
-        if filterwarnings_match:
-            has_filterwarnings = True
-        addopts_match = addopts_re.match(line)
-        if addopts_match and not modified:
-            addopts_found = True
-            indent, inner = addopts_match.group(1), addopts_match.group(2)
-            tokens = inner.split()
-            remaining_tokens: list[str] = []
-            extra_specs: list[str] = []
-
-            for tok in tokens:
-                if tok in unwanted_flags:
-                    # Discard it; it will be replaced by base_specs
-                    continue
-
-                w_match = w_flag_re.match(tok)
-                if w_match:
-                    w_flags.append(tok)
-                    has_w_flags = True
-                    spec = w_match.group(1)
-                    if spec:
-                        # Convert this -W... into a filterwarnings spec
-                        extra_specs.append(spec)
-                else:
-                    # Keep any non -W token
-                    remaining_tokens.append(tok)
-
-            # Base filterwarnings specs to replace unwanted flags
-            base_specs = map(
-                str.strip,
-                r"""
-                "error",
-                "once::DeprecationWarning",
-                "once::PendingDeprecationWarning",
-                # We ignore warnings about protobuf gencode version being one version older
-                # than the current version, as this is supported by protobuf, and we expect to
-                # have such cases. If we go too far, we will get a proper error anyways.
-                # We use a raw string (single quotes) to avoid the need to escape special
-                # characters as this is a regex.
-                'ignore:Protobuf gencode version .*exactly one major version older.*:UserWarning',
-                """.strip().splitlines(),
-            )
-
-            # Rebuild addopts line without unwanted flags
-            new_addopts_value = " ".join(remaining_tokens)
-            new_lines.append(f'{indent}addopts = "{new_addopts_value}"\n')
-
-            # Build the filterwarnings block
-            new_lines.append(f"{indent}filterwarnings = [\n")
-            # This is fine, indent is defined only once, so even if it is a closure
-            # bound late, the value will always be the same.
-            # pylint: disable-next=cell-var-from-loop
-            new_lines.extend(map(lambda s: f"{indent}  {s}\n", base_specs))
-            for spec in extra_specs:
-                new_lines.append(f'{indent}  "{spec}",\n')
-            new_lines.append(f"{indent}]\n")
-
-            modified = True
-        else:
-            new_lines.append(line)
-
-    if modified and not has_filterwarnings:
-        print(f"Updated {path} to use filterwarnings.")
-        path.write_text("".join(new_lines), encoding="utf-8")
-        return
-
-    if has_filterwarnings and not has_w_flags:
-        print(
-            f"The file {path} already has a `filterwarnings` section and has no "
-            "-W flags in `addopts`, it is probably already migrated."
-        )
-    elif has_filterwarnings and has_w_flags:
-        print(
-            f"The file {path} already has a `filterwarnings` section, but also "
-            f"has -W flags in `addopts` ({' '.join(w_flags)!r}), it looks like "
-            "it is half-migrated, you should probably migrate it manually. Avoid using -W "
-            "flags in `addopts` if there is a `filterwarnings` section."
-        )
-    if not addopts_found:
-        print(f"No 'addopts' found in {path}.")
-
-    manual_step(
-        f"No changes done to {path}. "
-        "Please double check no manual steps are required."
-    )
-
-
-def migrate_mkdocs_yaml(file_path: Path) -> None:
-    """Migrate the mkdocs.yml file to fix the `paths` key location."""
-    if not file_path.is_file():
-        manual_step(f"File {file_path} does not exist, skipping automatic migration.")
-        return
-
-    python_section = "        python:"
-    options_section = "          options:"
-    bad_paths_config = "            paths:"
-
-    lines = file_path.read_text(encoding="utf-8").splitlines(keepends=True)
-    needs_migration = False
-    paths = ""
-    in_python = False
-    in_options = False
-
-    # 1) Detect whether there's a python_section followed by options_section
-    #    and then bad_paths_config in that block.
-    for line in lines:
-        if line.startswith(python_section):
-            in_python = True
-            in_options = False
-            continue
-        if in_python and line.startswith(options_section):
-            in_options = True
-            continue
-        if in_options and line.startswith(bad_paths_config):
-            needs_migration = True
-            paths = line[len(bad_paths_config) :].strip()
-            break
-        # If indentation drops back below python-level, stop looking in this block
-        if in_python and not line.startswith("        ") and not line.isspace():
-            in_python = False
-            in_options = False
-
-    if not needs_migration:
-        return
-
-    # 2) Perform the line-based rewrite:
-    new_lines: list[str] = []
-    inserted_paths = False
-
-    for line in lines:
-        # When we hit the python_section line, insert new paths config directly under it
-        if line.startswith(python_section) and not inserted_paths:
-            new_lines.append(line)
-            new_lines.append(f"          paths: {paths}\n")
-            inserted_paths = True
-            continue
-
-        # After inserting, drop the old "            paths:" line
-        if inserted_paths and line.startswith(bad_paths_config):
-            continue
-
-        new_lines.append(line)
-
-    file_path.write_text("".join(new_lines), encoding="utf-8")
-
-
 def apply_patch(patch_content: str) -> None:
     """Apply a patch using the patch utility."""
     subprocess.run(["patch", "-p1"], input=patch_content.encode(), check=True)