Check repos for dependencies

Joel Grunbaum

23 hours ago 69c02d6ac5cb0eff81ae6b4f2daa09f7392809a6

Check repos for dependencies

 src/archrepobuild/cli.py

@@ -165,8 +165,8 @@
                    resolver = DependencyResolver(aur)

                    for pkg in repo.list_packages():
                        if resolver.is_in_official_repos(pkg.name):
                            console.print(f"[yellow]Removing {pkg.name}[/] (now in official repos)")
                        if resolver.is_in_repos(pkg.name):
                            console.print(f"[yellow]Removing {pkg.name}[/] (now in repositories)")
                            builder.remove_package(pkg.name)
                            repo.remove_package(pkg.name)
                else:
@@ -200,10 +200,10 @@
                    # Ignore debug packages if the regular version is in official repos
                    if pkg.name.endswith("-debug"):
                        base_name = pkg.name[:-6]
                        if resolver.is_in_official_repos(base_name, include_all=all_repos) or await aur.is_available(base_name):
                        if resolver.is_in_repos(base_name, include_all=all_repos) or await aur.is_available(base_name):
                            continue

                    if resolver.is_in_official_repos(pkg.name, include_all=all_repos):
                    if resolver.is_in_repos(pkg.name, include_all=all_repos):
                        in_official.append(pkg.name)
                    elif not await aur.is_available(pkg.name):
                        not_in_aur.append(pkg.name)

 src/archrepobuild/resolver.py

@@ -105,8 +105,8 @@
            logger.warning(f"Failed to get pacman package list: {e}")
            self._pacman_cache = {}

    def is_in_official_repos(self, name: str, include_all: bool = True) -> bool:
        """Check if package is available in official repositories.
    def is_in_repos(self, name: str, include_all: bool = True) -> bool:
        """Check if package is available in repositories.

        Args:
            name: Package name (without version constraint)
@@ -170,14 +170,15 @@
        all_deps: list[str] = []
        all_deps.extend(package.depends)
        all_deps.extend(package.makedepends)
        all_deps.extend(package.checkdepends)

        aur_deps: list[str] = []
        for dep in all_deps:
            dep_parsed = Dependency.parse(dep)
            base_name = dep_parsed.name

            # Skip if in official repos or already installed
            if self.is_in_official_repos(base_name):
            # Skip if in repos or already installed
            if self.is_in_repos(base_name):
                continue
            if self.is_installed(base_name):
                continue
@@ -292,11 +293,11 @@
        Raises:
            ValueError: If package not found or circular dependency
        """
        # Filter out packages already in official repos or installed
        # Filter out packages already in repos or installed
        aur_package_names = []
        for name in package_names:
            if self.is_in_official_repos(name):
                logger.info(f"Package {name} found in official repositories, skipping AUR lookup")
            if self.is_in_repos(name):
                logger.info(f"Package {name} found in repositories, skipping AUR lookup")
                continue
            if self.is_installed(name):
                logger.info(f"Package {name} is already installed, skipping AUR lookup")
@@ -339,12 +340,17 @@
                deps: list[Dependency] = []
                for dep in pkg.depends:
                    parsed = Dependency.parse(dep, DependencyType.RUNTIME)
                    if not self.is_in_official_repos(parsed.name):
                    if not self.is_in_repos(parsed.name):
                        parsed.is_aur = True
                    deps.append(parsed)
                for dep in pkg.makedepends:
                    parsed = Dependency.parse(dep, DependencyType.BUILD)
                    if not self.is_in_official_repos(parsed.name):
                    if not self.is_in_repos(parsed.name):
                        parsed.is_aur = True
                    deps.append(parsed)
                for dep in pkg.checkdepends:
                    parsed = Dependency.parse(dep, DependencyType.CHECK)
                    if not self.is_in_repos(parsed.name):
                        parsed.is_aur = True
                    deps.append(parsed)
                aur_deps[name] = deps

 tests/test_resolver.py

@@ -119,20 +119,72 @@
        assert len(cycles) > 0

    @patch("archrepobuild.resolver.subprocess.run")
    def test_is_in_official_repos(self, mock_run, mock_aur_client):
        """Test checking official repos."""
    def test_is_in_repos(self, mock_run, mock_aur_client):
        """Test checking repos."""
        mock_run.return_value.returncode = 0
        mock_run.return_value.stdout = "core base\nextra git\ncustom mypkg\n"

        resolver = DependencyResolver(mock_aur_client)
        
        # Test default (include_all=True)
        assert resolver.is_in_official_repos("git")
        assert resolver.is_in_official_repos("mypkg")
        assert resolver.is_in_official_repos("base")
        assert not resolver.is_in_official_repos("yay")
        assert resolver.is_in_repos("git")
        assert resolver.is_in_repos("mypkg")
        assert resolver.is_in_repos("base")
        assert not resolver.is_in_repos("yay")

        # Test official_only (include_all=False)
        assert resolver.is_in_official_repos("git", include_all=False)
        assert resolver.is_in_official_repos("base", include_all=False)
        assert not resolver.is_in_official_repos("mypkg", include_all=False)
        assert resolver.is_in_repos("git", include_all=False)
        assert resolver.is_in_repos("base", include_all=False)
        assert not resolver.is_in_repos("mypkg", include_all=False)

    @pytest.mark.asyncio
    async def test_resolve_includes_checkdepends(self, mock_aur_client):
        """Test that resolve includes checkdepends in the build order or dependency map."""
        from archrepobuild.aur import Package
        
        resolver = DependencyResolver(mock_aur_client)
        
        # Mock AUR response
        pkg = Package(
            name="test-pkg",
            version="1.0",
            description="test",
            url=None,
            maintainer=None,
            votes=0,
            popularity=0.0,
            out_of_date=None,
            first_submitted=None,
            last_modified=None,
            depends=[],
            makedepends=[],
            checkdepends=["check-dep"],
        )
        
        dep_pkg = Package(
            name="check-dep",
            version="1.0",
            description="test",
            url=None,
            maintainer=None,
            votes=0,
            popularity=0.0,
            out_of_date=None,
            first_submitted=None,
            last_modified=None,
            depends=[],
            makedepends=[],
            checkdepends=[],
        )
        
        mock_aur_client.get_packages.side_effect = [[pkg], [dep_pkg]]
        
        # Assume neither is in repos or installed
        with patch.object(resolver, "is_in_repos", return_value=False), \
             patch.object(resolver, "is_installed", return_value=False):
            
            build_order = await resolver.resolve(["test-pkg"])
            
            assert "check-dep" in build_order.packages
            assert "check-dep" in [d.name for d in build_order.aur_dependencies["test-pkg"]]
            assert any(d.dep_type == DependencyType.CHECK for d in build_order.aur_dependencies["test-pkg"])