Улучшения обработки зависимостей и фильтрации установленных пакетов

- Добавлена поддержка версионных ограничений при установке пакетов
- Улучшена логика фильтрации уже установленных пакетов
- Добавлен метод GetInstalledVersion для всех менеджеров пакетов
- Активированы тесты для систем archlinux, alpine, opensuse-leap
- Улучшена обработка переменных в скриптах

Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>

internal/manager/apk.go

@@ -167,3 +167,33 @@ func (a *APK) IsInstalled(pkg string) (bool, error) {
 	}
 	return true, nil
 }
+
+func (a *APK) GetInstalledVersion(pkg string) (string, error) {
+	cmd := exec.Command("apk", "info", "--installed", pkg)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			// Exit code 1 means the package is not installed
+			if exitErr.ExitCode() == 1 {
+				return "", nil
+			}
+		}
+		return "", fmt.Errorf("apk: getinstalledversion: %w, output: %s", err, output)
+	}
+
+	// Output format: "package-version" (e.g., "curl-8.5.0-r0")
+	// We need to extract just the version part
+	line := strings.TrimSpace(string(output))
+	if line == "" {
+		return "", nil
+	}
+
+	// Find the last hyphen that separates name from version
+	// Alpine package names can contain hyphens, version starts after last one
+	lastDash := strings.LastIndex(line, "-")
+	if lastDash == -1 {
+		return "", nil
+	}
+
+	return line[lastDash+1:], nil
+}

internal/manager/apt.go

@@ -82,8 +82,15 @@ func (a *APT) InstallLocal(opts *Opts, pkgs ...string) error {
 
 func (a *APT) Remove(opts *Opts, pkgs ...string) error {
 	opts = ensureOpts(opts)
+
+	resolvedPkgs := make([]string, 0, len(pkgs))
+	for _, pkg := range pkgs {
+		resolved := a.resolvePackageName(pkg)
+		resolvedPkgs = append(resolvedPkgs, resolved)
+	}
+
 	cmd := a.getCmd(opts, "apt", "remove")
-	cmd.Args = append(cmd.Args, pkgs...)
+	cmd.Args = append(cmd.Args, resolvedPkgs...)
 	setCmdEnv(cmd)
 	err := cmd.Run()
 	if err != nil {
@@ -92,6 +99,39 @@ func (a *APT) Remove(opts *Opts, pkgs ...string) error {
 	return nil
 }
 
+func (a *APT) resolvePackageName(pkg string) string {
+	cmd := exec.Command("dpkg-query", "-f", "${Status}", "-W", pkg)
+	output, err := cmd.Output()
+	if err == nil && strings.Contains(string(output), "install ok installed") {
+		return pkg
+	}
+
+	cmd = exec.Command("dpkg-query", "-W", "-f", "${Package}\t${Provides}\n")
+	output, err = cmd.Output()
+	if err != nil {
+		return pkg
+	}
+
+	for _, line := range strings.Split(string(output), "\n") {
+		parts := strings.SplitN(line, "\t", 2)
+		if len(parts) != 2 {
+			continue
+		}
+		pkgName := parts[0]
+		provides := parts[1]
+
+		for _, p := range strings.Split(provides, ", ") {
+			p = strings.TrimSpace(p)
+			provName := strings.Split(p, " ")[0]
+			if provName == pkg {
+				return pkgName
+			}
+		}
+	}
+
+	return pkg
+}
+
 func (a *APT) Upgrade(opts *Opts, pkgs ...string) error {
 	opts = ensureOpts(opts)
 	return a.Install(opts, pkgs...)
@@ -140,11 +180,11 @@ func (a *APT) ListInstalled(opts *Opts) (map[string]string, error) {
 }
 
 func (a *APT) IsInstalled(pkg string) (bool, error) {
-	cmd := exec.Command("dpkg-query", "-f", "${Status}", "-W", pkg)
+	resolved := a.resolvePackageName(pkg)
+	cmd := exec.Command("dpkg-query", "-f", "${Status}", "-W", resolved)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		if exitErr, ok := err.(*exec.ExitError); ok {
-			// Код выхода 1 означает что пакет не найден
 			if exitErr.ExitCode() == 1 {
 				return false, nil
 			}
@@ -153,6 +193,21 @@ func (a *APT) IsInstalled(pkg string) (bool, error) {
 	}
 
 	status := strings.TrimSpace(string(output))
-	// Проверяем что пакет действительно установлен (статус должен содержать "install ok installed")
 	return strings.Contains(status, "install ok installed"), nil
 }
+
+func (a *APT) GetInstalledVersion(pkg string) (string, error) {
+	resolved := a.resolvePackageName(pkg)
+	cmd := exec.Command("dpkg-query", "-f", "${Version}", "-W", resolved)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			if exitErr.ExitCode() == 1 {
+				return "", nil
+			}
+		}
+		return "", fmt.Errorf("apt: getinstalledversion: %w, output: %s", err, output)
+	}
+
+	return strings.TrimSpace(string(output)), nil
+}

internal/manager/common_rpm.go

@@ -70,3 +70,21 @@ func (a *CommonRPM) IsInstalled(pkg string) (bool, error) {
 	}
 	return true, nil
 }
+
+func (a *CommonRPM) GetInstalledVersion(pkg string) (string, error) {
+	cmd := exec.Command("rpm", "-q", "--queryformat", "%|EPOCH?{%{EPOCH}:}:{}|%{VERSION}-%{RELEASE}", pkg)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			if exitErr.ExitCode() == 1 {
+				return "", nil
+			}
+		}
+		return "", fmt.Errorf("rpm: getinstalledversion: %w, output: %s", err, output)
+	}
+
+	version := strings.TrimSpace(string(output))
+	// Remove epoch 0: prefix if present
+	version = strings.TrimPrefix(version, "0:")
+	return version, nil
+}

internal/manager/manager_test.go

@@ -0,0 +1,59 @@
+// ALR - Any Linux Repository
+// Copyright (C) 2025 The ALR Authors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package manager
+
+import (
+	"testing"
+)
+
+func TestNewZypperReturnsCorrectType(t *testing.T) {
+	z := NewZypper()
+	if z == nil {
+		t.Fatal("NewZypper() returned nil")
+	}
+	if z.Name() != "zypper" {
+		t.Errorf("Expected name 'zypper', got '%s'", z.Name())
+	}
+	if z.Format() != "rpm" {
+		t.Errorf("Expected format 'rpm', got '%s'", z.Format())
+	}
+}
+
+func TestManagersOrder(t *testing.T) {
+	// Проверяем, что APT-RPM идёт раньше APT в списке менеджеров
+	aptRpmIndex := -1
+	aptIndex := -1
+
+	for i, m := range managers {
+		switch m.Name() {
+		case "apt-rpm":
+			aptRpmIndex = i
+		case "apt":
+			aptIndex = i
+		}
+	}
+
+	if aptRpmIndex == -1 {
+		t.Fatal("APT-RPM not found in managers list")
+	}
+	if aptIndex == -1 {
+		t.Fatal("APT not found in managers list")
+	}
+	if aptRpmIndex >= aptIndex {
+		t.Errorf("APT-RPM (index %d) should come before APT (index %d)", aptRpmIndex, aptIndex)
+	}
+}

internal/manager/managers.go

@@ -37,12 +37,12 @@ var DefaultOpts = &Opts{
 
 var managers = []Manager{
 	NewPacman(),
+	NewAPTRpm(), // APT-RPM должен проверяться раньше APT, т.к. на ALT Linux есть оба
 	NewAPT(),
 	NewDNF(),
 	NewYUM(),
 	NewAPK(),
 	NewZypper(),
-	NewAPTRpm(),
 }
 
 // Register registers a new package manager
@@ -74,8 +74,11 @@ type Manager interface {
 	UpgradeAll(*Opts) error
 	// ListInstalled returns all installed packages mapped to their versions
 	ListInstalled(*Opts) (map[string]string, error)
-	//
+	// IsInstalled checks if a package is installed
 	IsInstalled(string) (bool, error)
+	// GetInstalledVersion returns the version of an installed package.
+	// Returns empty string and no error if package is not installed.
+	GetInstalledVersion(string) (string, error)
 }
 
 // Detect returns the package manager detected on the system

internal/manager/pacman.go

@@ -160,3 +160,24 @@ func (p *Pacman) IsInstalled(pkg string) (bool, error) {
 	}
 	return true, nil
 }
+
+func (p *Pacman) GetInstalledVersion(pkg string) (string, error) {
+	cmd := exec.Command("pacman", "-Q", pkg)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		// Pacman returns exit code 1 if the package is not found
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			if exitErr.ExitCode() == 1 {
+				return "", nil
+			}
+		}
+		return "", fmt.Errorf("pacman: getinstalledversion: %w, output: %s", err, output)
+	}
+
+	// Output format: "package-name version"
+	_, version, ok := strings.Cut(strings.TrimSpace(string(output)), " ")
+	if !ok {
+		return "", nil
+	}
+	return version, nil
+}

internal/manager/zypper.go

@@ -30,8 +30,8 @@ type Zypper struct {
 	CommonRPM
 }
 
-func NewZypper() *YUM {
-	return &YUM{
+func NewZypper() *Zypper {
+	return &Zypper{
 		CommonPackageManager: CommonPackageManager{
 			noConfirmArg: "-y",
 		},