feat(12): cache formulajson (#13)

* moved update homebrew command

* refactored brew service to support formulae cache file

* fix copilot suggestion

Author: Valkyrie00

internal/services/app.go

@@ -71,27 +71,28 @@ func (s *AppService) GetApp() *tview.Application {
 }
 
 func (s *AppService) Boot() (err error) {
-	if err = s.BrewService.LoadAllFormulae(); err != nil {
+	if s.brewVersion, err = s.BrewService.GetBrewVersion(); err != nil {
+		// This error is critical, as we need Homebrew to function
+		return fmt.Errorf("failed to get Homebrew version: %v", err)
+	}
+
+	// Download and parse Homebrew formulae data
+	if err = s.BrewService.SetupData(false); err != nil {
 		return fmt.Errorf("failed to load Homebrew formulae: %v", err)
 	}
 
-	s.packages = s.BrewService.GetAllFormulae()
+	s.packages = s.BrewService.GetFormulae()
 	*s.filteredPackages = *s.packages
 
-	if s.brewVersion, err = s.BrewService.GetCurrentBrewVersion(); err != nil {
-		return fmt.Errorf("failed to get Homebrew version: %v", err)
-	}
-
 	return nil
 }
 
 func (s *AppService) updateHomeBrew() {
 	s.layout.GetNotifier().ShowWarning("Updating Homebrew formulae...")
-	if err := s.CommandService.UpdateHomebrew(); err != nil {
+	if err := s.BrewService.UpdateHomebrew(); err != nil {
 		s.layout.GetNotifier().ShowError("Could not update Homebrew formulae")
 		return
 	}
-
 	// Clear loading message and update results
 	s.layout.GetNotifier().ShowSuccess("Homebrew formulae updated successfully")
 	s.forceRefreshResults()
@@ -230,7 +231,7 @@ func (s *AppService) getPackageInstallationDetails(info *models.Formula) string
 		return "[yellow::b]Installation[-]\nNot installed"
 	}
 
-	packagePrefix, _ := s.BrewService.GetPrefixPath(info.Name)
+	packagePrefix := s.BrewService.GetPrefixPath() + "/" + info.Name
 	installedOnRequest := "No"
 	if info.Installed[0].InstalledOnRequest {
 		installedOnRequest = "Yes"
@@ -289,8 +290,11 @@ func (s *AppService) getAnalyticsInfo(info *models.Formula) string {
 }
 
 func (s *AppService) forceRefreshResults() {
+	_ = s.BrewService.SetupData(true)
+	s.packages = s.BrewService.GetFormulae()
+	*s.filteredPackages = *s.packages
+
 	s.app.QueueUpdateDraw(func() {
-		_ = s.BrewService.LoadAllFormulae()
 		s.search(s.layout.GetSearch().Field().GetText(), false)
 	})
 }

internal/services/brew.go

@@ -3,91 +3,86 @@ package services
 import (
 	"bbrew/internal/models"
 	"encoding/json"
+	"io"
 	"net/http"
+	"os"
 	"os/exec"
+	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
-	"sync"
 )
 
-var prefixPathCache = make(map[string]string)
+const FormulaeAPIURL = "https://formulae.brew.sh/api/formula.json"
+const AnalyticsAPIURL = "https://formulae.brew.sh/api/analytics/install-on-request/90d.json"
 
 type BrewServiceInterface interface {
-	GetPrefixPath(packageName string) (path string, err error)
-	GetAllFormulae() (formulae *[]models.Formula)
-	LoadAllFormulae() (err error)
-	GetCurrentBrewVersion() (version string, err error)
+	GetPrefixPath() (path string)
+	GetFormulae() (formulae *[]models.Formula)
+	SetupData(forceDownload bool) (err error)
+	GetBrewVersion() (version string, err error)
+	UpdateHomebrew() error
 }
 
 type BrewService struct {
-	cache     sync.Mutex
+	// Package lists
 	all       *[]models.Formula
 	installed *[]models.Formula
 	remote    *[]models.Formula
 	analytics map[string]models.AnalyticsItem
+
+	brewVersion string
+	prefixPath  string
 }
 
 var NewBrewService = func() BrewServiceInterface {
 	return &BrewService{
-		cache:     sync.Mutex{},
 		all:       new([]models.Formula),
 		installed: new([]models.Formula),
 		remote:    new([]models.Formula),
 	}
 }
 
-func (s *BrewService) GetPrefixPath(packageName string) (path string, err error) {
-	s.cache.Lock()
-	defer s.cache.Unlock()
-
-	var found bool
-	if path, found = prefixPathCache[packageName]; found {
-		return path, nil
+func (s *BrewService) GetPrefixPath() (path string) {
+	if s.prefixPath != "" {
+		return s.prefixPath
 	}
 
-	cmd := exec.Command("brew", "--prefix", packageName)
+	cmd := exec.Command("brew", "--prefix")
 	output, err := cmd.Output()
 	if err != nil {
-		return "Unknown", err
+		s.prefixPath = "Unknown"
+		return
 	}
 
-	path = strings.TrimSpace(string(output))
-	prefixPathCache[packageName] = path
-	return path, nil
+	s.prefixPath = strings.TrimSpace(string(output))
+	return s.prefixPath
 }
 
-func (s *BrewService) GetAllFormulae() (formulae *[]models.Formula) {
-	return s.all
-}
-
-func (s *BrewService) LoadAllFormulae() (err error) {
-	_ = s.loadInstalled()
-	_ = s.loadRemote()
-	_ = s.loadAnalytics()
-
+func (s *BrewService) GetFormulae() (formulae *[]models.Formula) {
 	packageMap := make(map[string]models.Formula)
 
-	// Add installed packages to the map
-	for _, formula := range *s.installed {
-		packageMap[formula.Name] = formula
-	}
-
 	// Add remote packages to the map if they don't already exist
 	for _, formula := range *s.remote {
 		if _, exists := packageMap[formula.Name]; !exists {
 			packageMap[formula.Name] = formula
 		}
 	}
 
+	// Add installed packages to the map
+	for _, formula := range *s.installed {
+		packageMap[formula.Name] = formula
+	}
+
 	*s.all = make([]models.Formula, 0, len(packageMap))
 	for _, formula := range packageMap {
-		// patch analytics info
+		// Merge analytics data if available
 		if a, exists := s.analytics[formula.Name]; exists && a.Number > 0 {
 			downloads, _ := strconv.Atoi(strings.ReplaceAll(a.Count, ",", ""))
 			formula.Analytics90dRank = a.Number
 			formula.Analytics90dDownloads = downloads
 		}
+
 		*s.all = append(*s.all, formula)
 	}
 
@@ -96,6 +91,22 @@ func (s *BrewService) LoadAllFormulae() (err error) {
 		return (*s.all)[i].Name < (*s.all)[j].Name
 	})
 
+	return s.all
+}
+
+func (s *BrewService) SetupData(forceDownload bool) (err error) {
+	if err = s.loadInstalled(); err != nil {
+		return err
+	}
+
+	if err = s.loadRemote(forceDownload); err != nil {
+		return err
+	}
+
+	if err = s.loadAnalytics(); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -120,24 +131,57 @@ func (s *BrewService) loadInstalled() (err error) {
 	return nil
 }
 
-func (s *BrewService) loadRemote() (err error) {
-	resp, err := http.Get("https://formulae.brew.sh/api/formula.json")
+func (s *BrewService) loadRemote(forceDownload bool) (err error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return err
+	}
+
+	bbrewDir := filepath.Join(homeDir, ".bbrew") // TODO: Move to config
+	formulaFile := filepath.Join(bbrewDir, "formula.json")
+	if _, err := os.Stat(bbrewDir); os.IsNotExist(err) {
+		if err := os.MkdirAll(bbrewDir, 0755); err != nil {
+			return err
+		}
+	}
+
+	// Check if we should use the cached file
+	if !forceDownload {
+		if _, err := os.Stat(formulaFile); err == nil {
+			data, err := os.ReadFile(formulaFile)
+			if err == nil {
+				*s.remote = make([]models.Formula, 0)
+				if err := json.Unmarshal(data, &s.remote); err == nil {
+					return nil
+				}
+			}
+		}
+	}
+
+	resp, err := http.Get(FormulaeAPIURL)
 	if err != nil {
 		return err
 	}
 	defer resp.Body.Close()
 
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
 	*s.remote = make([]models.Formula, 0)
-	err = json.NewDecoder(resp.Body).Decode(&s.remote)
+	err = json.Unmarshal(body, s.remote)
 	if err != nil {
 		return err
 	}
 
+	// Cache the remote formulae data
+	_ = os.WriteFile(formulaFile, body, 0600)
 	return nil
 }
 
 func (s *BrewService) loadAnalytics() (err error) {
-	resp, err := http.Get("https://formulae.brew.sh/api/analytics/install-on-request/90d.json")
+	resp, err := http.Get(AnalyticsAPIURL)
 	if err != nil {
 		return err
 	}
@@ -155,16 +199,28 @@ func (s *BrewService) loadAnalytics() (err error) {
 	}
 
 	s.analytics = analyticsByFormula
-
 	return nil
 }
 
-func (s *BrewService) GetCurrentBrewVersion() (version string, err error) {
+func (s *BrewService) GetBrewVersion() (version string, err error) {
+	if s.brewVersion != "" {
+		return s.brewVersion, nil
+	}
+
 	cmd := exec.Command("brew", "--version")
 	output, err := cmd.Output()
 	if err != nil {
 		return "", err
 	}
 
-	return strings.TrimSpace(string(output)), nil
+	s.brewVersion = strings.TrimSpace(string(output))
+	return s.brewVersion, nil
+}
+
+func (s *BrewService) UpdateHomebrew() error {
+	cmd := exec.Command("brew", "update")
+	if err := cmd.Run(); err != nil {
+		return err
+	}
+	return nil
 }

internal/services/command.go

@@ -14,7 +14,6 @@ type CommandServiceInterface interface {
 	UpdatePackage(info models.Formula, app *tview.Application, outputView *tview.TextView) error
 	RemovePackage(info models.Formula, app *tview.Application, outputView *tview.TextView) error
 	InstallPackage(info models.Formula, app *tview.Application, outputView *tview.TextView) error
-	UpdateHomebrew() error
 }
 
 type CommandService struct{}
@@ -43,14 +42,6 @@ func (s *CommandService) InstallPackage(info models.Formula, app *tview.Applicat
 	return s.executeCommand(app, cmd, outputView)
 }
 
-func (s *CommandService) UpdateHomebrew() error {
-	cmd := exec.Command("brew", "update")
-	if err := cmd.Run(); err != nil {
-		return err
-	}
-	return nil
-}
-
 func (s *CommandService) executeCommand(
 	app *tview.Application,
 	cmd *exec.Cmd,