simplify the driver interface

app/mem/drivers/dmidecode.go

@@ -10,12 +10,36 @@ import (
 
 type DmiDecodeDriver struct{}
 
-func NewDmiDecodeDriver() *DmiDecodeDriver {
-	return &DmiDecodeDriver{}
+func NewDmiDecodeDriver() (*DmiDecodeDriver, error) {
+	r := DmiDecodeDriver{}
+	_, err := r.Read()
+	return &r, err
+}
+
+func (r *DmiDecodeDriver) Render(console *strings.Builder) error {
+	h, err := r.Read()
+	if err != nil {
+		return err
+	}
+
+	hardware := h.(MemoryHardware)
+
+	for i := range len(hardware.ModelNames) {
+		fmt.Fprintf(console, "--- RAM Module %d ---\n", i)
+		modelName := hardware.ModelNames[i]
+		fmt.Fprintf(console, "%-16s | %-16s \033[K\n", "Model Name", modelName)
+		generation := hardware.Generations[i]
+		speed := hardware.Speeds[i]
+		fmt.Fprintf(console, "%-16s | %s@%s \033[K\n", "Speed", generation, speed)
+		formFactor := hardware.FormFactors[i]
+		fmt.Fprintf(console, "%-16s | %s \033[K\n", "Form Factor", formFactor)
+	}
+
+	return nil
 }
 
 // Parses dmidecode to extract physical hardware limits, slot counts, and module details
-func (r *DmiDecodeDriver) ReadHardwareSensors() (MemoryHardware, error) {
+func (r *DmiDecodeDriver) Read() (any, error) {
 	hw := MemoryHardware{}
 
 	// Query Memory Array (Type 16) for Max Capacity and Slot Count

app/mem/drivers/drivers.go

@@ -8,10 +8,6 @@ type MemoryUsage struct {
 	UsedPercent float64
 }
 
-type UsageDriver interface {
-	ReadUsageSensors() (MemoryUsage, error)
-}
-
 // MemoryHardware holds physical RAM slot and module details
 type MemoryHardware struct {
 	MaxCapacityGB float64
@@ -22,7 +18,3 @@ type MemoryHardware struct {
 	FormFactors   []string
 	ModelNames    []string
 }
-
-type HardwareDriver interface {
-	ReadHardwareSensors() (MemoryHardware, error)
-}

app/mem/drivers/meminfo.go

@@ -2,6 +2,7 @@ package drivers
 
 import (
 	"bufio"
+	"fmt"
 	"os"
 	"strconv"
 	"strings"
@@ -9,12 +10,30 @@ import (
 
 type MemInfoDriver struct{}
 
-func NewMemInfoDriver() *MemInfoDriver {
-	return &MemInfoDriver{}
+func NewMemInfoDriver() (*MemInfoDriver, error) {
+	r := MemInfoDriver{}
+	_, err := r.Read()
+	return &r, err
+}
+
+func (r *MemInfoDriver) Render(console *strings.Builder) error {
+	u, err := r.Read()
+	if err != nil {
+		return err
+	}
+
+	usage := u.(MemoryUsage)
+
+	fmt.Fprintf(console, "--- Usage ---\n")
+	fmt.Fprintf(console, "%-16s | %.2f GiB\033[K\n", "Total", usage.TotalGB)
+	fmt.Fprintf(console, "%-16s | %.2f GiB (%.2f%%) \033[K\n", "Used", usage.UsedGB, usage.UsedPercent)
+	fmt.Fprintf(console, "%-16s | %.2f GiB\033[K\n", "Avail", usage.AvailableGB)
+
+	return nil
 }
 
 // Read /proc/meminfo for active system memory statistics
-func (r *MemInfoDriver) ReadUsageSensors() (MemoryUsage, error) {
+func (r *MemInfoDriver) Read() (any, error) {
 	usage := MemoryUsage{}
 	file, err := os.Open("/proc/meminfo")
 	if err != nil {

app/mem/mem.go

@@ -1,69 +1,36 @@
 package mem
 
 import (
+	"finally-a-monolithic-linux-hw-monitor/app/common"
 	"finally-a-monolithic-linux-hw-monitor/app/mem/drivers"
 	"fmt"
 	"strings"
 )
 
-func RenderMem(console *strings.Builder, mem *Mem) {
+func (mem *Mem) Render(console *strings.Builder) {
 	fmt.Fprintf(console, "=== %s ===\n", "Memory")
-	RenderUsageSensors(console, mem)
-	RenderHardwareSensors(console, mem)
-}
-
-func RenderUsageSensors(console *strings.Builder, mem *Mem) {
-	usage, _ := mem.SensorReader.ReadUsageSensors()
-	fmt.Fprintf(console, "--- Usage ---\n")
-	fmt.Fprintf(console, "%-16s | %.2f GiB\033[K\n", "Total", usage.TotalGB)
-	fmt.Fprintf(console, "%-16s | %.2f GiB (%.2f%%) \033[K\n", "Used", usage.UsedGB, usage.UsedPercent)
-	fmt.Fprintf(console, "%-16s | %.2f GiB\033[K\n", "Avail", usage.AvailableGB)
-}
-
-func RenderHardwareSensors(console *strings.Builder, mem *Mem) {
-	hardware, _ := mem.SensorReader.ReadHardwareSensors()
-	for i := range len(hardware.ModelNames) {
-		fmt.Fprintf(console, "--- RAM Module %d ---\n", i)
-		modelName := hardware.ModelNames[i]
-		fmt.Fprintf(console, "%-16s | %-16s \033[K\n", "Model Name", modelName)
-		generation := hardware.Generations[i]
-		speed := hardware.Speeds[i]
-		fmt.Fprintf(console, "%-16s | %s@%s \033[K\n", "Speed", generation, speed)
-		formFactor := hardware.FormFactors[i]
-		fmt.Fprintf(console, "%-16s | %s \033[K\n", "Form Factor", formFactor)
+	for _, driver := range mem.drivers {
+		driver.Render(console)
 	}
 }
 
 type Mem struct {
-	SensorReader MemSensorReader
+	drivers []common.Driver
 }
 
 func GetMem() (Mem, error) {
-	memInfoDriver := drivers.NewMemInfoDriver()
-	dmiDecodeDriver := drivers.NewDmiDecodeDriver()
-	reader := &StandardMemSensorReader{
-		UsageReader:    memInfoDriver,
-		HardwareReader: dmiDecodeDriver,
+	mem := Mem{}
+	mem.drivers = []common.Driver{}
+
+	meminfo, err := drivers.NewMemInfoDriver()
+	if err == nil {
+		mem.drivers = append(mem.drivers, meminfo)
 	}
-	return Mem{
-		SensorReader: reader,
-	}, nil
-}
 
-type MemSensorReader interface {
-	ReadUsageSensors() (drivers.MemoryUsage, error)
-	ReadHardwareSensors() (drivers.MemoryHardware, error)
-}
+	dmidecode, err := drivers.NewDmiDecodeDriver()
+	if err == nil {
+		mem.drivers = append(mem.drivers, dmidecode)
+	}
 
-type StandardMemSensorReader struct {
-	UsageReader    drivers.UsageDriver
-	HardwareReader drivers.HardwareDriver
-}
-
-func (r *StandardMemSensorReader) ReadUsageSensors() (drivers.MemoryUsage, error) {
-	return r.UsageReader.ReadUsageSensors()
-}
-
-func (r *StandardMemSensorReader) ReadHardwareSensors() (drivers.MemoryHardware, error) {
-	return r.HardwareReader.ReadHardwareSensors()
+	return mem, nil
 }