Feature: Partial support for formulae from taps (#333)

Author: Zweih

README.md

@@ -143,10 +143,22 @@ learn about installation [here](#installation)
 | ✓ | bottles in brew | ✓ | casks in brew |
 | - | replaced-by resolution | - | multi-license support |
 | – | short-args for queries | ✓ | key/value output |
-| - | rpm origin (dnf/yum support) | - | homebrew packaging |
+| - | rpm origin (dnf/yum support) | ✓ | homebrew packaging |
+| - | pip origin (python packaging) | - | formulae from taps (brew) |
+| - | casks from taps (brew) | - | dependencies for casks |
 
 ## installation
 
+### homebrew (macOS or linuxbrew)
+
+if you have [homebrew](https://brew.sh/) (`brew`), install via `qp`'s cask repo:
+```bash
+brew tap zweih/qp
+brew install zweih/qp/qp
+```
+
+**note**: until we are added to the official `homebrew/core` repo, ensure that the package you install is `zweih/qp/qp`
+
 ### arch-based systems (AUR)
 
 install using an [AUR helper](https://wiki.archlinux.org/title/AUR_helpers) like `yay`, `paru`, `aura`, etc.:

internal/origins/drivers/brew/discover.go

@@ -7,13 +7,13 @@ import (
 	"strings"
 )
 
-func getInstalledFormulae(cellarRoot, binRoot string) ([]installedPkg, error) {
+func getInstalledFormulae(cellarRoot, binRoot string) ([]*installedPkg, error) {
 	entries, err := os.ReadDir(cellarRoot)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read Cellar directory: %w", err)
 	}
 
-	var pkgs []installedPkg
+	var iPkgs []*installedPkg
 	for _, entry := range entries {
 		if !entry.IsDir() {
 			continue
@@ -25,15 +25,15 @@ func getInstalledFormulae(cellarRoot, binRoot string) ([]installedPkg, error) {
 			continue
 		}
 
-		pkgs = append(pkgs, installedPkg{
+		iPkgs = append(iPkgs, &installedPkg{
 			Name:        name,
 			Version:     version,
-			ReceiptPath: filepath.Join(cellarRoot, name, version, receiptName),
 			VersionPath: filepath.Join(cellarRoot, name, version),
+			IsTap:       true,
 		})
 	}
 
-	return pkgs, nil
+	return iPkgs, nil
 }
 
 func resolveLinkedVersion(pkgName string, cellarRoot string, binRoot string) (string, error) {
@@ -67,3 +67,60 @@ func resolveLinkedVersion(pkgName string, cellarRoot string, binRoot string) (st
 
 	return parts[len(parts)-3], nil
 }
+
+func getTapPackageNames(prefix string, pkgType string) (map[string]struct{}, error) {
+	tapsRoot := filepath.Join(prefix, "Homebrew/Library/Taps")
+	result := make(map[string]struct{})
+
+	users, err := os.ReadDir(tapsRoot)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, user := range users {
+		userPath := filepath.Join(tapsRoot, user.Name())
+		repos, err := os.ReadDir(userPath)
+		if err != nil {
+			continue
+		}
+
+		for _, repo := range repos {
+			if !repo.IsDir() {
+				continue
+			}
+
+			repoPath := filepath.Join(userPath, repo.Name())
+			var searchDirs []string
+
+			switch pkgType {
+			case typeFormula:
+				searchDirs = []string{
+					filepath.Join(repoPath, "Formula"),
+					filepath.Join(repoPath, "HomebrewFormula"),
+					repoPath,
+				}
+			case typeCask:
+				searchDirs = []string{filepath.Join(repoPath, "Casks")}
+			default:
+				continue
+			}
+
+			for _, dir := range searchDirs {
+				entries, err := os.ReadDir(dir)
+				if err != nil {
+					continue
+				}
+
+				for _, entry := range entries {
+					if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".rb") {
+						name := strings.TrimSuffix(entry.Name(), ".rb")
+						result[name] = struct{}{}
+					}
+				}
+				break
+			}
+		}
+	}
+
+	return result, nil
+}

internal/origins/drivers/brew/fetch_formulae.go

@@ -10,9 +10,8 @@ import (
 type installedPkg struct {
 	Name        string
 	Version     string
-	ReceiptPath string
 	VersionPath string
-	ModTime     int64
+	IsTap       bool
 }
 
 func fetchFormulae(
@@ -34,9 +33,13 @@ func fetchFormulae(
 		return
 	}
 
-	wanted := make(map[string]struct{}, len(installedPkgs))
+	tapPkgs, _ := getTapPackageNames(prefix, typeFormula)
+	wanted := make(map[string]struct{})
 	for _, iPkg := range installedPkgs {
-		wanted[iPkg.Name] = struct{}{}
+		if _, fromTap := tapPkgs[iPkg.Name]; !fromTap {
+			wanted[iPkg.Name] = struct{}{}
+			iPkg.IsTap = false
+		}
 	}
 
 	var formulaMeta map[string]*FormulaMetadata
@@ -49,7 +52,7 @@ func fetchFormulae(
 		formulaMeta, metaErr = loadMetadata(formulaCachePath, getFormulaKey, wanted)
 	}()
 
-	inputChan := make(chan installedPkg, len(installedPkgs))
+	inputChan := make(chan *installedPkg, len(installedPkgs))
 	for _, iPkg := range installedPkgs {
 		inputChan <- iPkg
 	}
@@ -60,8 +63,8 @@ func fetchFormulae(
 		inputChan,
 		errChan,
 		errGroup,
-		func(iPkg installedPkg) (*pkgdata.PkgInfo, error) {
-			return parseFormulaReceipt(iPkg.ReceiptPath, iPkg.Version)
+		func(iPkg *installedPkg) (*pkgdata.PkgInfo, error) {
+			return parseFormulaReceipt(iPkg)
 		},
 		0,
 		len(installedPkgs),

internal/origins/drivers/brew/formula_parser.go

@@ -6,7 +6,6 @@ import (
 	"path/filepath"
 	"qp/internal/consts"
 	"qp/internal/pkgdata"
-	"strings"
 
 	json "github.com/goccy/go-json"
 )
@@ -34,8 +33,8 @@ type FormulaMetadata struct {
 	RecommendedDependencies []string `json:"recommended_dependencies"`
 }
 
-func parseFormulaReceipt(path string, version string) (*pkgdata.PkgInfo, error) {
-	data, err := os.ReadFile(path)
+func parseFormulaReceipt(iPkg *installedPkg) (*pkgdata.PkgInfo, error) {
+	data, err := os.ReadFile(filepath.Join(iPkg.VersionPath, receiptName))
 	if err != nil {
 		return nil, fmt.Errorf("failed to read receipt JSON: %v", err)
 	}
@@ -45,26 +44,25 @@ func parseFormulaReceipt(path string, version string) (*pkgdata.PkgInfo, error)
 		return nil, fmt.Errorf("failed to parse receipt JSON: %v", err)
 	}
 
-	pkgName, err := getPkgNameFromPath(path)
-	if err != nil {
-		return nil, err
-	}
-
 	reason := consts.ReasonExplicit
 	if !receipt.InstalledOnRequest {
 		reason = consts.ReasonDependency
 	}
 
 	pkg := &pkgdata.PkgInfo{
 		InstallTimestamp: receipt.Time,
-		Name:             pkgName,
+		Name:             iPkg.Name,
 		Reason:           reason,
-		Version:          version,
+		Version:          iPkg.Version,
 		Arch:             receipt.Arch,
 		PkgType:          typeFormula,
 		Depends:          parseDepends(receipt),
 	}
 
+	if iPkg.IsTap {
+		inferTapMetadata(pkg, iPkg.VersionPath)
+	}
+
 	inferBuildDate(pkg, receipt)
 
 	return pkg, nil
@@ -76,16 +74,6 @@ func inferBuildDate(pkg *pkgdata.PkgInfo, receipt FormulaReceipt) {
 	}
 }
 
-func getPkgNameFromPath(path string) (string, error) {
-	parts := strings.Split(filepath.Clean(path), string(os.PathSeparator))
-
-	if len(parts) >= 3 {
-		return parts[len(parts)-3], nil
-	}
-
-	return "", fmt.Errorf("unexpected receipt path format: %s", path)
-}
-
 func parseDepends(receipt FormulaReceipt) []pkgdata.Relation {
 	rels := make([]pkgdata.Relation, 0, len(receipt.RuntimeDependencies))