gogrlx/snack
1
0
Fork 0
mirror of https://github.com/gogrlx/snack.git synced 2026-04-02 05:08:42 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/copilot/add-install-remove-changes-reporting' into cd/integration-copilot-prs

Browse Source
This commit is contained in:
Tai Groot
2026-02-28 07:07:00 +00:00
parent ae56fb541d a3e4827e5e
commit b0e39036de
34 changed files with 751 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
apk/apk.go
View File

@@ -27,14 +27,14 @@ func (a *Apk) Name() string { return "apk" }
func (a *Apk) Available() bool { return available() }
// Install one or more packages.
func (a *Apk) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (a *Apk) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
a.Lock()
defer a.Unlock()
return install(ctx, pkgs, opts...)
}
// Remove one or more packages.
func (a *Apk) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (a *Apk) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
a.Lock()
defer a.Unlock()
return remove(ctx, pkgs, opts...)

69
apk/apk_linux.go
View File

@@ -66,16 +66,69 @@ func formatTargets(targets []snack.Target) []string {
return args
}
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
args := append([]string{"add"}, formatTargets(pkgs)...)
_, err := run(ctx, args, opts...)
return err
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
o := snack.ApplyOptions(opts...)
var toInstall []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.Reinstall || t.Version != "" || o.DryRun {
toInstall = append(toInstall, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.InstallResult{}, err
}
if ok {
unchanged = append(unchanged, t.Name)
} else {
toInstall = append(toInstall, t)
}
}
if len(toInstall) > 0 {
args := append([]string{"add"}, formatTargets(toInstall)...)
if _, err := run(ctx, args, opts...); err != nil {
return snack.InstallResult{}, err
}
}
var installed []snack.Package
for _, t := range toInstall {
v, _ := version(ctx, t.Name)
installed = append(installed, snack.Package{Name: t.Name, Version: v, Installed: true})
}
return snack.InstallResult{Installed: installed, Unchanged: unchanged}, nil
}
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
args := append([]string{"del"}, snack.TargetNames(pkgs)...)
_, err := run(ctx, args, opts...)
return err
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
o := snack.ApplyOptions(opts...)
var toRemove []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.DryRun {
toRemove = append(toRemove, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.RemoveResult{}, err
}
if !ok {
unchanged = append(unchanged, t.Name)
} else {
toRemove = append(toRemove, t)
}
}
if len(toRemove) > 0 {
args := append([]string{"del"}, snack.TargetNames(toRemove)...)
if _, err := run(ctx, args, opts...); err != nil {
return snack.RemoveResult{}, err
}
}
var removed []snack.Package
for _, t := range toRemove {
removed = append(removed, snack.Package{Name: t.Name})
}
return snack.RemoveResult{Removed: removed, Unchanged: unchanged}, nil
}
func purge(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {

8
apk/apk_other.go
View File

@@ -10,12 +10,12 @@ import (
func available() bool { return false }
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.InstallResult, error) {
return snack.InstallResult{}, snack.ErrUnsupportedPlatform
}
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.RemoveResult, error) {
return snack.RemoveResult{}, snack.ErrUnsupportedPlatform
}
func purge(_ context.Context, _ []snack.Target, _ ...snack.Option) error {

4
apt/apt.go
View File

@@ -21,14 +21,14 @@ func New() *Apt {
func (a *Apt) Name() string { return "apt" }
// Install one or more packages.
func (a *Apt) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (a *Apt) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
a.Lock()
defer a.Unlock()
return install(ctx, pkgs, opts...)
}
// Remove one or more packages.
func (a *Apt) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (a *Apt) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
a.Lock()
defer a.Unlock()
return remove(ctx, pkgs, opts...)

63
apt/apt_linux.go
View File

@@ -77,12 +77,67 @@ func runAptGet(ctx context.Context, command string, pkgs []snack.Target, opts ..
return nil
}
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
return runAptGet(ctx, "install", pkgs, opts...)
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
o := snack.ApplyOptions(opts...)
var toInstall []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.Reinstall || t.Version != "" || o.DryRun {
toInstall = append(toInstall, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.InstallResult{}, err
}
if ok {
unchanged = append(unchanged, t.Name)
} else {
toInstall = append(toInstall, t)
}
}
if len(toInstall) > 0 {
if err := runAptGet(ctx, "install", toInstall, opts...); err != nil {
return snack.InstallResult{}, err
}
}
var installed []snack.Package
for _, t := range toInstall {
v, _ := version(ctx, t.Name)
installed = append(installed, snack.Package{Name: t.Name, Version: v, Installed: true})
}
return snack.InstallResult{Installed: installed, Unchanged: unchanged}, nil
}
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
return runAptGet(ctx, "remove", pkgs, opts...)
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
o := snack.ApplyOptions(opts...)
var toRemove []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.DryRun {
toRemove = append(toRemove, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.RemoveResult{}, err
}
if !ok {
unchanged = append(unchanged, t.Name)
} else {
toRemove = append(toRemove, t)
}
}
if len(toRemove) > 0 {
if err := runAptGet(ctx, "remove", toRemove, opts...); err != nil {
return snack.RemoveResult{}, err
}
}
var removed []snack.Package
for _, t := range toRemove {
removed = append(removed, snack.Package{Name: t.Name})
}
return snack.RemoveResult{Removed: removed, Unchanged: unchanged}, nil
}
func purge(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {

8
apt/apt_other.go
View File

@@ -10,12 +10,12 @@ import (
func available() bool { return false }
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.InstallResult, error) {
return snack.InstallResult{}, snack.ErrUnsupportedPlatform
}
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.RemoveResult, error) {
return snack.RemoveResult{}, snack.ErrUnsupportedPlatform
}
func purge(_ context.Context, _ []snack.Target, _ ...snack.Option) error {

6
cmd/snack/main.go
View File

@@ -102,7 +102,8 @@ func installCmd() *cobra.Command {
if err != nil {
return err
}
return m.Install(cmd.Context(), targets(args, ver), opts()...)
_, err = m.Install(cmd.Context(), targets(args, ver), opts()...)
return err
},
}
cmd.Flags().StringVar(&ver, "version", "", "pin version for all targets")
@@ -119,7 +120,8 @@ func removeCmd() *cobra.Command {
if err != nil {
return err
}
return m.Remove(cmd.Context(), snack.Targets(args...), opts()...)
_, err = m.Remove(cmd.Context(), snack.Targets(args...), opts()...)
return err
},
}
}

11
dnf/dnf.go
View File

@@ -31,24 +31,25 @@ func (d *DNF) Name() string { return "dnf" }
func (d *DNF) Available() bool { return available() }
// Install one or more packages.
func (d *DNF) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (d *DNF) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
d.Lock()
defer d.Unlock()
return install(ctx, pkgs, opts...)
return install(ctx, d.v5, pkgs, opts...)
}
// Remove one or more packages.
func (d *DNF) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (d *DNF) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
d.Lock()
defer d.Unlock()
return remove(ctx, pkgs, opts...)
return remove(ctx, d.v5, pkgs, opts...)
}
// Purge removes packages including configuration files (same as Remove for dnf).
func (d *DNF) Purge(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
d.Lock()
defer d.Unlock()
return remove(ctx, pkgs, opts...)
_, err := remove(ctx, d.v5, pkgs, opts...)
return err
}
// Upgrade all installed packages to their latest versions.

93
dnf/dnf_linux.go
View File

@@ -89,34 +89,85 @@ func formatTargets(targets []snack.Target) []string {
return args
}
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func install(ctx context.Context, v5 bool, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
o := snack.ApplyOptions(opts...)
base := []string{"install", "-y"}
if o.Refresh {
base = append(base, "--refresh")
}
if o.FromRepo != "" {
base = append(base, "--repo="+o.FromRepo)
}
if o.Reinstall {
base[0] = "reinstall"
}
var toInstall []snack.Target
var unchanged []string
for _, t := range pkgs {
if t.FromRepo != "" {
base = append(base, "--repo="+t.FromRepo)
break
if o.Reinstall || t.Version != "" || o.DryRun {
toInstall = append(toInstall, t)
continue
}
ok, err := isInstalled(ctx, t.Name, v5)
if err != nil {
return snack.InstallResult{}, err
}
if ok {
unchanged = append(unchanged, t.Name)
} else {
toInstall = append(toInstall, t)
}
}
args := append(base, formatTargets(pkgs)...)
_, err := run(ctx, args, o)
return err
if len(toInstall) > 0 {
base := []string{"install", "-y"}
if o.Refresh {
base = append(base, "--refresh")
}
if o.FromRepo != "" {
base = append(base, "--repo="+o.FromRepo)
}
if o.Reinstall {
base[0] = "reinstall"
}
for _, t := range toInstall {
if t.FromRepo != "" {
base = append(base, "--repo="+t.FromRepo)
break
}
}
args := append(base, formatTargets(toInstall)...)
if _, err := run(ctx, args, o); err != nil {
return snack.InstallResult{}, err
}
}
var installed []snack.Package
for _, t := range toInstall {
v, _ := version(ctx, t.Name, v5)
installed = append(installed, snack.Package{Name: t.Name, Version: v, Installed: true})
}
return snack.InstallResult{Installed: installed, Unchanged: unchanged}, nil
}
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func remove(ctx context.Context, v5 bool, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
o := snack.ApplyOptions(opts...)
args := append([]string{"remove", "-y"}, snack.TargetNames(pkgs)...)
_, err := run(ctx, args, o)
return err
var toRemove []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.DryRun {
toRemove = append(toRemove, t)
continue
}
ok, err := isInstalled(ctx, t.Name, v5)
if err != nil {
return snack.RemoveResult{}, err
}
if !ok {
unchanged = append(unchanged, t.Name)
} else {
toRemove = append(toRemove, t)
}
}
if len(toRemove) > 0 {
args := append([]string{"remove", "-y"}, snack.TargetNames(toRemove)...)
if _, err := run(ctx, args, o); err != nil {
return snack.RemoveResult{}, err
}
}
var removed []snack.Package
for _, t := range toRemove {
removed = append(removed, snack.Package{Name: t.Name})
}
return snack.RemoveResult{Removed: removed, Unchanged: unchanged}, nil
}
func upgrade(ctx context.Context, opts ...snack.Option) error {

8
dnf/dnf_other.go
View File

@@ -12,12 +12,12 @@ func available() bool { return false }
func (d *DNF) detectVersion() {}
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func install(_ context.Context, _ bool, _ []snack.Target, _ ...snack.Option) (snack.InstallResult, error) {
return snack.InstallResult{}, snack.ErrUnsupportedPlatform
}
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func remove(_ context.Context, _ bool, _ []snack.Target, _ ...snack.Option) (snack.RemoveResult, error) {
return snack.RemoveResult{}, snack.ErrUnsupportedPlatform
}
func upgrade(_ context.Context, _ ...snack.Option) error {

4
dpkg/dpkg.go
View File

@@ -21,14 +21,14 @@ func New() *Dpkg {
func (d *Dpkg) Name() string { return "dpkg" }
// Install one or more .deb files.
func (d *Dpkg) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (d *Dpkg) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
d.Lock()
defer d.Unlock()
return install(ctx, pkgs, opts...)
}
// Remove one or more packages.
func (d *Dpkg) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (d *Dpkg) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
d.Lock()
defer d.Unlock()
return remove(ctx, pkgs, opts...)

118
dpkg/dpkg_linux.go
View File

@@ -17,55 +17,101 @@ func available() bool {
return err == nil
}
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
o := snack.ApplyOptions(opts...)
var args []string
if o.Sudo {
args = append(args, "sudo")
}
args = append(args, "dpkg", "-i")
if o.DryRun {
args = append(args, "--simulate")
}
// dpkg -i takes file paths; use Source if set, otherwise Name
var toInstall []snack.Target
var unchanged []string
for _, t := range pkgs {
if t.Source != "" {
args = append(args, t.Source)
if o.Reinstall || t.Version != "" || o.DryRun {
toInstall = append(toInstall, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.InstallResult{}, err
}
if ok {
unchanged = append(unchanged, t.Name)
} else {
args = append(args, t.Name)
toInstall = append(toInstall, t)
}
}
cmd := exec.CommandContext(ctx, args[0], args[1:]...)
var stderr bytes.Buffer
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
errMsg := stderr.String()
if strings.Contains(errMsg, "Permission denied") || strings.Contains(errMsg, "are you root") {
return fmt.Errorf("dpkg -i: %w", snack.ErrPermissionDenied)
if len(toInstall) > 0 {
var args []string
if o.Sudo {
args = append(args, "sudo")
}
args = append(args, "dpkg", "-i")
if o.DryRun {
args = append(args, "--simulate")
}
for _, t := range toInstall {
if t.Source != "" {
args = append(args, t.Source)
} else {
args = append(args, t.Name)
}
}
cmd := exec.CommandContext(ctx, args[0], args[1:]...)
var stderr bytes.Buffer
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
errMsg := stderr.String()
if strings.Contains(errMsg, "Permission denied") || strings.Contains(errMsg, "are you root") {
return snack.InstallResult{}, fmt.Errorf("dpkg -i: %w", snack.ErrPermissionDenied)
}
return snack.InstallResult{}, fmt.Errorf("dpkg -i: %w: %s", err, errMsg)
}
return fmt.Errorf("dpkg -i: %w: %s", err, errMsg)
}
return nil
var installed []snack.Package
for _, t := range toInstall {
v, _ := version(ctx, t.Name)
installed = append(installed, snack.Package{Name: t.Name, Version: v, Installed: true})
}
return snack.InstallResult{Installed: installed, Unchanged: unchanged}, nil
}
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
o := snack.ApplyOptions(opts...)
var args []string
if o.Sudo {
args = append(args, "sudo")
var toRemove []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.DryRun {
toRemove = append(toRemove, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.RemoveResult{}, err
}
if !ok {
unchanged = append(unchanged, t.Name)
} else {
toRemove = append(toRemove, t)
}
}
args = append(args, "dpkg", "-r")
if o.DryRun {
args = append(args, "--simulate")
if len(toRemove) > 0 {
var args []string
if o.Sudo {
args = append(args, "sudo")
}
args = append(args, "dpkg", "-r")
if o.DryRun {
args = append(args, "--simulate")
}
args = append(args, snack.TargetNames(toRemove)...)
cmd := exec.CommandContext(ctx, args[0], args[1:]...)
var stderr bytes.Buffer
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
return snack.RemoveResult{}, fmt.Errorf("dpkg -r: %w: %s", err, stderr.String())
}
}
args = append(args, snack.TargetNames(pkgs)...)
cmd := exec.CommandContext(ctx, args[0], args[1:]...)
var stderr bytes.Buffer
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
return fmt.Errorf("dpkg -r: %w: %s", err, stderr.String())
var removed []snack.Package
for _, t := range toRemove {
removed = append(removed, snack.Package{Name: t.Name})
}
return nil
return snack.RemoveResult{Removed: removed, Unchanged: unchanged}, nil
}
func purge(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {

8
dpkg/dpkg_other.go
View File

@@ -10,12 +10,12 @@ import (
func available() bool { return false }
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.InstallResult, error) {
return snack.InstallResult{}, snack.ErrUnsupportedPlatform
}
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.RemoveResult, error) {
return snack.RemoveResult{}, snack.ErrUnsupportedPlatform
}
func purge(_ context.Context, _ []snack.Target, _ ...snack.Option) error {

4
flatpak/flatpak.go
View File

@@ -24,14 +24,14 @@ func (f *Flatpak) Name() string { return "flatpak" }
func (f *Flatpak) Available() bool { return available() }
// Install one or more packages.
func (f *Flatpak) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (f *Flatpak) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
f.Lock()
defer f.Unlock()
return install(ctx, pkgs, opts...)
}
// Remove one or more packages.
func (f *Flatpak) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (f *Flatpak) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
f.Lock()
defer f.Unlock()
return remove(ctx, pkgs, opts...)

64
flatpak/flatpak_linux.go
View File

@@ -33,25 +33,73 @@ func run(ctx context.Context, args []string) (string, error) {
return stdout.String(), nil
}
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
_ = snack.ApplyOptions(opts...)
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
o := snack.ApplyOptions(opts...)
var toInstall []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.Reinstall || t.Version != "" || o.DryRun {
toInstall = append(toInstall, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.InstallResult{}, err
}
if ok {
unchanged = append(unchanged, t.Name)
} else {
toInstall = append(toInstall, t)
}
}
for _, t := range toInstall {
remote := t.FromRepo
if remote == "" {
remote = "flathub"
}
args := []string{"install", "-y", remote, t.Name}
if _, err := run(ctx, args); err != nil {
return err
return snack.InstallResult{}, err
}
}
return nil
var installed []snack.Package
for _, t := range toInstall {
v, _ := version(ctx, t.Name)
installed = append(installed, snack.Package{Name: t.Name, Version: v, Installed: true})
}
return snack.InstallResult{Installed: installed, Unchanged: unchanged}, nil
}
func remove(ctx context.Context, pkgs []snack.Target, _ ...snack.Option) error {
args := append([]string{"uninstall", "-y"}, snack.TargetNames(pkgs)...)
_, err := run(ctx, args)
return err
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
o := snack.ApplyOptions(opts...)
var toRemove []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.DryRun {
toRemove = append(toRemove, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.RemoveResult{}, err
}
if !ok {
unchanged = append(unchanged, t.Name)
} else {
toRemove = append(toRemove, t)
}
}
if len(toRemove) > 0 {
args := append([]string{"uninstall", "-y"}, snack.TargetNames(toRemove)...)
if _, err := run(ctx, args); err != nil {
return snack.RemoveResult{}, err
}
}
var removed []snack.Package
for _, t := range toRemove {
removed = append(removed, snack.Package{Name: t.Name})
}
return snack.RemoveResult{Removed: removed, Unchanged: unchanged}, nil
}
func purge(ctx context.Context, pkgs []snack.Target, _ ...snack.Option) error {

8
flatpak/flatpak_other.go
View File

@@ -10,12 +10,12 @@ import (
func available() bool { return false }
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.InstallResult, error) {
return snack.InstallResult{}, snack.ErrUnsupportedPlatform
}
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.RemoveResult, error) {
return snack.RemoveResult{}, snack.ErrUnsupportedPlatform
}
func purge(_ context.Context, _ []snack.Target, _ ...snack.Option) error {

4
pacman/pacman.go
View File

@@ -24,14 +24,14 @@ func (p *Pacman) Name() string { return "pacman" }
func (p *Pacman) Available() bool { return available() }
// Install one or more packages.
func (p *Pacman) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (p *Pacman) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
p.Lock()
defer p.Unlock()
return install(ctx, pkgs, opts...)
}
// Remove one or more packages.
func (p *Pacman) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (p *Pacman) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
p.Lock()
defer p.Unlock()
return remove(ctx, pkgs, opts...)

75
pacman/pacman_linux.go
View File

@@ -72,28 +72,73 @@ func formatTargets(targets []snack.Target) []string {
return args
}
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
o := snack.ApplyOptions(opts...)
base := []string{"-S", "--noconfirm"}
if o.Refresh {
base = []string{"-Sy", "--noconfirm"}
}
var toInstall []snack.Target
var unchanged []string
for _, t := range pkgs {
if t.FromRepo != "" || o.FromRepo != "" {
// Not directly supported by pacman CLI; user should configure repos
break
if o.Reinstall || t.Version != "" || o.DryRun {
toInstall = append(toInstall, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.InstallResult{}, err
}
if ok {
unchanged = append(unchanged, t.Name)
} else {
toInstall = append(toInstall, t)
}
}
args := append(base, formatTargets(pkgs)...)
_, err := run(ctx, args, o)
return err
if len(toInstall) > 0 {
base := []string{"-S", "--noconfirm"}
if o.Refresh {
base = []string{"-Sy", "--noconfirm"}
}
args := append(base, formatTargets(toInstall)...)
if _, err := run(ctx, args, o); err != nil {
return snack.InstallResult{}, err
}
}
var installed []snack.Package
for _, t := range toInstall {
v, _ := version(ctx, t.Name)
installed = append(installed, snack.Package{Name: t.Name, Version: v, Installed: true})
}
return snack.InstallResult{Installed: installed, Unchanged: unchanged}, nil
}
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
o := snack.ApplyOptions(opts...)
args := append([]string{"-R", "--noconfirm"}, snack.TargetNames(pkgs)...)
_, err := run(ctx, args, o)
return err
var toRemove []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.DryRun {
toRemove = append(toRemove, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.RemoveResult{}, err
}
if !ok {
unchanged = append(unchanged, t.Name)
} else {
toRemove = append(toRemove, t)
}
}
if len(toRemove) > 0 {
args := append([]string{"-R", "--noconfirm"}, snack.TargetNames(toRemove)...)
if _, err := run(ctx, args, o); err != nil {
return snack.RemoveResult{}, err
}
}
var removed []snack.Package
for _, t := range toRemove {
removed = append(removed, snack.Package{Name: t.Name})
}
return snack.RemoveResult{Removed: removed, Unchanged: unchanged}, nil
}
func purge(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {

8
pacman/pacman_other.go
View File

@@ -10,12 +10,12 @@ import (
func available() bool { return false }
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.InstallResult, error) {
return snack.InstallResult{}, snack.ErrUnsupportedPlatform
}
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.RemoveResult, error) {
return snack.RemoveResult{}, snack.ErrUnsupportedPlatform
}
func purge(_ context.Context, _ []snack.Target, _ ...snack.Option) error {

4
pkg/pkg.go
View File

@@ -24,14 +24,14 @@ func (p *Pkg) Name() string { return "pkg" }
func (p *Pkg) Available() bool { return available() }
// Install one or more packages.
func (p *Pkg) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (p *Pkg) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
p.Lock()
defer p.Unlock()
return install(ctx, pkgs, opts...)
}
// Remove one or more packages.
func (p *Pkg) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (p *Pkg) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
p.Lock()
defer p.Unlock()
return remove(ctx, pkgs, opts...)

67
pkg/pkg_freebsd.go
View File

@@ -54,18 +54,69 @@ func formatTargets(targets []snack.Target) []string {
return args
}
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
o := snack.ApplyOptions(opts...)
args := append([]string{"install", "-y"}, formatTargets(pkgs)...)
_, err := run(ctx, args, o)
return err
var toInstall []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.Reinstall || t.Version != "" || o.DryRun {
toInstall = append(toInstall, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.InstallResult{}, err
}
if ok {
unchanged = append(unchanged, t.Name)
} else {
toInstall = append(toInstall, t)
}
}
if len(toInstall) > 0 {
args := append([]string{"install", "-y"}, formatTargets(toInstall)...)
if _, err := run(ctx, args, o); err != nil {
return snack.InstallResult{}, err
}
}
var installed []snack.Package
for _, t := range toInstall {
v, _ := version(ctx, t.Name)
installed = append(installed, snack.Package{Name: t.Name, Version: v, Installed: true})
}
return snack.InstallResult{Installed: installed, Unchanged: unchanged}, nil
}
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
o := snack.ApplyOptions(opts...)
args := append([]string{"delete", "-y"}, snack.TargetNames(pkgs)...)
_, err := run(ctx, args, o)
return err
var toRemove []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.DryRun {
toRemove = append(toRemove, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.RemoveResult{}, err
}
if !ok {
unchanged = append(unchanged, t.Name)
} else {
toRemove = append(toRemove, t)
}
}
if len(toRemove) > 0 {
args := append([]string{"delete", "-y"}, snack.TargetNames(toRemove)...)
if _, err := run(ctx, args, o); err != nil {
return snack.RemoveResult{}, err
}
}
var removed []snack.Package
for _, t := range toRemove {
removed = append(removed, snack.Package{Name: t.Name})
}
return snack.RemoveResult{Removed: removed, Unchanged: unchanged}, nil
}
func purge(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {

8
pkg/pkg_other.go
View File

@@ -10,12 +10,12 @@ import (
func available() bool { return false }
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.InstallResult, error) {
return snack.InstallResult{}, snack.ErrUnsupportedPlatform
}
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.RemoveResult, error) {
return snack.RemoveResult{}, snack.ErrUnsupportedPlatform
}
func purge(_ context.Context, _ []snack.Target, _ ...snack.Option) error {

4
ports/ports.go
View File

@@ -24,14 +24,14 @@ func (p *Ports) Name() string { return "ports" }
func (p *Ports) Available() bool { return available() }
// Install one or more packages.
func (p *Ports) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (p *Ports) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
p.Lock()
defer p.Unlock()
return install(ctx, pkgs, opts...)
}
// Remove one or more packages.
func (p *Ports) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (p *Ports) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
p.Lock()
defer p.Unlock()
return remove(ctx, pkgs, opts...)

65
ports/ports_openbsd.go
View File

@@ -42,18 +42,67 @@ func runCmd(ctx context.Context, name string, args []string, opts snack.Options)
return stdout.String(), nil
}
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
o := snack.ApplyOptions(opts...)
args := snack.TargetNames(pkgs)
_, err := runCmd(ctx, "pkg_add", args, o)
return err
var toInstall []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.Reinstall || t.Version != "" || o.DryRun {
toInstall = append(toInstall, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.InstallResult{}, err
}
if ok {
unchanged = append(unchanged, t.Name)
} else {
toInstall = append(toInstall, t)
}
}
if len(toInstall) > 0 {
if _, err := runCmd(ctx, "pkg_add", snack.TargetNames(toInstall), o); err != nil {
return snack.InstallResult{}, err
}
}
var installed []snack.Package
for _, t := range toInstall {
v, _ := version(ctx, t.Name)
installed = append(installed, snack.Package{Name: t.Name, Version: v, Installed: true})
}
return snack.InstallResult{Installed: installed, Unchanged: unchanged}, nil
}
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
o := snack.ApplyOptions(opts...)
args := snack.TargetNames(pkgs)
_, err := runCmd(ctx, "pkg_delete", args, o)
return err
var toRemove []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.DryRun {
toRemove = append(toRemove, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.RemoveResult{}, err
}
if !ok {
unchanged = append(unchanged, t.Name)
} else {
toRemove = append(toRemove, t)
}
}
if len(toRemove) > 0 {
if _, err := runCmd(ctx, "pkg_delete", snack.TargetNames(toRemove), o); err != nil {
return snack.RemoveResult{}, err
}
}
var removed []snack.Package
for _, t := range toRemove {
removed = append(removed, snack.Package{Name: t.Name})
}
return snack.RemoveResult{Removed: removed, Unchanged: unchanged}, nil
}
func purge(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {

8
ports/ports_other.go
View File

@@ -10,12 +10,12 @@ import (
func available() bool { return false }
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.InstallResult, error) {
return snack.InstallResult{}, snack.ErrUnsupportedPlatform
}
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.RemoveResult, error) {
return snack.RemoveResult{}, snack.ErrUnsupportedPlatform
}
func purge(_ context.Context, _ []snack.Target, _ ...snack.Option) error {

7
rpm/rpm.go
View File

@@ -24,14 +24,14 @@ func (r *RPM) Name() string { return "rpm" }
func (r *RPM) Available() bool { return available() }
// Install one or more packages.
func (r *RPM) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (r *RPM) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
r.Lock()
defer r.Unlock()
return install(ctx, pkgs, opts...)
}
// Remove one or more packages.
func (r *RPM) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (r *RPM) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
r.Lock()
defer r.Unlock()
return remove(ctx, pkgs, opts...)
@@ -41,7 +41,8 @@ func (r *RPM) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Opt
func (r *RPM) Purge(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
r.Lock()
defer r.Unlock()
return remove(ctx, pkgs, opts...)
_, err := remove(ctx, pkgs, opts...)
return err
}
// Upgrade upgrades packages from files.

67
rpm/rpm_linux.go
View File

@@ -67,18 +67,69 @@ func formatSources(targets []snack.Target) []string {
return args
}
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
o := snack.ApplyOptions(opts...)
args := append([]string{"-i"}, formatSources(pkgs)...)
_, err := runWithSudo(ctx, args, o.Sudo)
return err
var toInstall []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.Reinstall || t.Version != "" || o.DryRun {
toInstall = append(toInstall, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.InstallResult{}, err
}
if ok {
unchanged = append(unchanged, t.Name)
} else {
toInstall = append(toInstall, t)
}
}
if len(toInstall) > 0 {
args := append([]string{"-i"}, formatSources(toInstall)...)
if _, err := runWithSudo(ctx, args, o.Sudo); err != nil {
return snack.InstallResult{}, err
}
}
var installed []snack.Package
for _, t := range toInstall {
v, _ := version(ctx, t.Name)
installed = append(installed, snack.Package{Name: t.Name, Version: v, Installed: true})
}
return snack.InstallResult{Installed: installed, Unchanged: unchanged}, nil
}
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
o := snack.ApplyOptions(opts...)
args := append([]string{"-e"}, snack.TargetNames(pkgs)...)
_, err := runWithSudo(ctx, args, o.Sudo)
return err
var toRemove []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.DryRun {
toRemove = append(toRemove, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.RemoveResult{}, err
}
if !ok {
unchanged = append(unchanged, t.Name)
} else {
toRemove = append(toRemove, t)
}
}
if len(toRemove) > 0 {
args := append([]string{"-e"}, snack.TargetNames(toRemove)...)
if _, err := runWithSudo(ctx, args, o.Sudo); err != nil {
return snack.RemoveResult{}, err
}
}
var removed []snack.Package
for _, t := range toRemove {
removed = append(removed, snack.Package{Name: t.Name})
}
return snack.RemoveResult{Removed: removed, Unchanged: unchanged}, nil
}
func upgradeAll(ctx context.Context, opts ...snack.Option) error {

8
rpm/rpm_other.go
View File

@@ -10,12 +10,12 @@ import (
func available() bool { return false }
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.InstallResult, error) {
return snack.InstallResult{}, snack.ErrUnsupportedPlatform
}
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.RemoveResult, error) {
return snack.RemoveResult{}, snack.ErrUnsupportedPlatform
}
func upgradeAll(_ context.Context, _ ...snack.Option) error {

8
snack.go
View File

@@ -58,11 +58,11 @@ func Targets(names ...string) []Target {
// log.Warn("hold not supported by", mgr.Name())
// }
type Manager interface {
// Install one or more packages.
Install(ctx context.Context, pkgs []Target, opts ...Option) error
// Install one or more packages. Returns a result describing what changed.
Install(ctx context.Context, pkgs []Target, opts ...Option) (InstallResult, error)
// Remove one or more packages.
Remove(ctx context.Context, pkgs []Target, opts ...Option) error
// Remove one or more packages. Returns a result describing what changed.
Remove(ctx context.Context, pkgs []Target, opts ...Option) (RemoveResult, error)
// Purge one or more packages (remove including config files).
Purge(ctx context.Context, pkgs []Target, opts ...Option) error

36
snack_test.go
View File

@@ -115,3 +115,39 @@ func TestErrors(t *testing.T) {
}
}
}
func TestInstallResult(t *testing.T) {
r := snack.InstallResult{
Installed: []snack.Package{{Name: "nginx", Version: "1.24.0", Installed: true}},
Unchanged: []string{"curl"},
}
assert.Len(t, r.Installed, 1)
assert.Equal(t, "nginx", r.Installed[0].Name)
assert.Equal(t, "1.24.0", r.Installed[0].Version)
assert.True(t, r.Installed[0].Installed)
assert.Empty(t, r.Updated)
assert.Equal(t, []string{"curl"}, r.Unchanged)
}
func TestRemoveResult(t *testing.T) {
r := snack.RemoveResult{
Removed: []snack.Package{{Name: "nginx", Version: "1.24.0"}},
Unchanged: []string{"wget"},
}
assert.Len(t, r.Removed, 1)
assert.Equal(t, "nginx", r.Removed[0].Name)
assert.Equal(t, []string{"wget"}, r.Unchanged)
}
func TestInstallResult_Zero(t *testing.T) {
var r snack.InstallResult
assert.Nil(t, r.Installed)
assert.Nil(t, r.Updated)
assert.Nil(t, r.Unchanged)
}
func TestRemoveResult_Zero(t *testing.T) {
var r snack.RemoveResult
assert.Nil(t, r.Removed)
assert.Nil(t, r.Unchanged)
}

4
snap/snap.go
View File

@@ -24,14 +24,14 @@ func (s *Snap) Name() string { return "snap" }
func (s *Snap) Available() bool { return available() }
// Install one or more packages.
func (s *Snap) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (s *Snap) Install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
s.Lock()
defer s.Unlock()
return install(ctx, pkgs, opts...)
}
// Remove one or more packages.
func (s *Snap) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
func (s *Snap) Remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
s.Lock()
defer s.Unlock()
return remove(ctx, pkgs, opts...)

65
snap/snap_linux.go
View File

@@ -37,11 +37,27 @@ func run(ctx context.Context, args []string) (string, error) {
return stdout.String(), nil
}
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) error {
_ = snack.ApplyOptions(opts...)
func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.InstallResult, error) {
o := snack.ApplyOptions(opts...)
var toInstall []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.Reinstall || t.Version != "" || o.DryRun {
toInstall = append(toInstall, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.InstallResult{}, err
}
if ok {
unchanged = append(unchanged, t.Name)
} else {
toInstall = append(toInstall, t)
}
}
for _, t := range toInstall {
args := []string{"install"}
// Handle --classic or --channel via FromRepo
if t.FromRepo != "" {
if t.FromRepo == "classic" {
args = append(args, "--classic")
@@ -51,16 +67,47 @@ func install(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) err
}
args = append(args, t.Name)
if _, err := run(ctx, args); err != nil {
return err
return snack.InstallResult{}, err
}
}
return nil
var installed []snack.Package
for _, t := range toInstall {
v, _ := version(ctx, t.Name)
installed = append(installed, snack.Package{Name: t.Name, Version: v, Installed: true})
}
return snack.InstallResult{Installed: installed, Unchanged: unchanged}, nil
}
func remove(ctx context.Context, pkgs []snack.Target, _ ...snack.Option) error {
args := append([]string{"remove"}, snack.TargetNames(pkgs)...)
_, err := run(ctx, args)
return err
func remove(ctx context.Context, pkgs []snack.Target, opts ...snack.Option) (snack.RemoveResult, error) {
o := snack.ApplyOptions(opts...)
var toRemove []snack.Target
var unchanged []string
for _, t := range pkgs {
if o.DryRun {
toRemove = append(toRemove, t)
continue
}
ok, err := isInstalled(ctx, t.Name)
if err != nil {
return snack.RemoveResult{}, err
}
if !ok {
unchanged = append(unchanged, t.Name)
} else {
toRemove = append(toRemove, t)
}
}
if len(toRemove) > 0 {
args := append([]string{"remove"}, snack.TargetNames(toRemove)...)
if _, err := run(ctx, args); err != nil {
return snack.RemoveResult{}, err
}
}
var removed []snack.Package
for _, t := range toRemove {
removed = append(removed, snack.Package{Name: t.Name})
}
return snack.RemoveResult{Removed: removed, Unchanged: unchanged}, nil
}
func purge(ctx context.Context, pkgs []snack.Target, _ ...snack.Option) error {

8
snap/snap_other.go
View File

@@ -10,12 +10,12 @@ import (
func available() bool { return false }
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func install(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.InstallResult, error) {
return snack.InstallResult{}, snack.ErrUnsupportedPlatform
}
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) error {
return snack.ErrUnsupportedPlatform
func remove(_ context.Context, _ []snack.Target, _ ...snack.Option) (snack.RemoveResult, error) {
return snack.RemoveResult{}, snack.ErrUnsupportedPlatform
}
func purge(_ context.Context, _ []snack.Target, _ ...snack.Option) error {

20
types.go
View File

@@ -1,5 +1,25 @@
package snack
// InstallResult holds the outcome of an Install operation.
type InstallResult struct {
// Installed contains packages that were newly installed by this operation.
Installed []Package
// Updated contains packages that were upgraded by this operation.
Updated []Package
// Unchanged contains the names of packages that were already at the
// desired state and required no action.
Unchanged []string
}
// RemoveResult holds the outcome of a Remove operation.
type RemoveResult struct {
// Removed contains packages that were removed by this operation.
Removed []Package
// Unchanged contains the names of packages that were not installed
// and required no action.
Unchanged []string
}
// Package represents a system package.
type Package struct {
Name string `json:"name"`