Resolved GH-2

Author: Lord of Scripts

browsers/chromium/chromium.go

@@ -106,20 +106,7 @@ func NewChromiumCleaner(profile string, smode cmn.SizeMode, logger ...cmn.ILogge
  *-----------------------------------------------------------------*/
 
 func (c *ChromiumCleaner) String() string {
-	var reportedSize string = ""
-	switch c.sizeMode {
-	case cmn.SizeModeSI:
-		reportedSize = cmn.ByteCountSI(c.cleanedSize)
-		break
-	case cmn.SizeModeIEC:
-		reportedSize = cmn.ByteCountIEC(c.cleanedSize)
-		break
-	case cmn.SizeModeStd:
-		fallthrough
-	default:
-		reportedSize = cmn.AddThousands(c.cleanedSize, ',')
-		break
-	}
+	reportedSize := cmn.ReportByteCount(c.cleanedSize, c.sizeMode)
 
 	c.logx.Print("Cleaned ", cmn.AddThousands(c.cleanedSize, ','))
 	c.logx.Print("Cleaned ", cmn.ByteCountSI(c.cleanedSize))
@@ -173,9 +160,16 @@ func (c *ChromiumCleaner) Tell() bool {
 	ChromiumDataDir, ChromiumCachesDir := GetChromiumDirs()
 	dataExists := cmn.IsDirectory(ChromiumDataDir)
 	cacheExists := cmn.IsDirectory(ChromiumCachesDir)
+	var sizeD, sizeC int64
+	if dataExists {
+		sizeD, _ = cmn.GetDirectorySize(ChromiumDataDir)
+	}
+	if cacheExists {
+		sizeC, _ = cmn.GetDirectorySize(ChromiumCachesDir)
+	}
 	fmt.Println("Chromium Directories:")
-	fmt.Println("\tData : ", ChromiumDataDir, dataExists)
-	fmt.Println("\tCache: ", ChromiumCachesDir, cacheExists)
+	fmt.Printf("\tData : %5t %s %s\n", dataExists, ChromiumDataDir, cmn.ReportByteCount(sizeD, c.sizeMode))
+	fmt.Printf("\tCache: %5t %s %s\n", cacheExists, ChromiumCachesDir, cmn.ReportByteCount(sizeC, c.sizeMode))
 	return dataExists && cacheExists
 }
 
@@ -232,7 +226,7 @@ func (c *ChromiumCleaner) clearCache() error {
 	}
 
 	c.cleanedSize += cacheSize
-	fmt.Printf("\tDeleted %s bytes from cache\n", cmn.AddThousands(cacheSize, ','))
+	fmt.Printf("\tDeleted %s bytes from cache\n", cmn.ReportByteCount(cacheSize, c.sizeMode))
 	c.logx.Print("clearCache DONE")
 	return nil
 }
@@ -249,7 +243,7 @@ func (c *ChromiumCleaner) eraseProfile() error {
 
 	// (b) we are going to clean the profile's top level
 	var filter cmn.IDirCleaner
-	filter = cmn.NewDirCleaner(c.ProfileRoot)
+	filter = cmn.NewDirCleaner(c.ProfileRoot, c.sizeMode)
 
 	// (c) except these important profile items
 	err := filter.CleanUp(ProfileExceptions)
@@ -259,7 +253,7 @@ func (c *ChromiumCleaner) eraseProfile() error {
 	}
 
 	c.cleanedSize += filter.CleanedSize()
-	fmt.Printf("\t...Erased %d bytes\n", c.cleanedSize)
+	fmt.Printf("\t...Erased %s bytes\n", cmn.ReportByteCount(c.cleanedSize, c.sizeMode))
 	return nil
 }
 

byte_count.go

@@ -14,6 +14,25 @@ import (
  *							F u n c t i o n s
  *-----------------------------------------------------------------*/
 
+// Given a total size return a string with that value formatted in
+// either of the size formats (Standard, International, Binary)
+func ReportByteCount(count int64, mode SizeMode) string {
+	var output string
+	switch mode {
+	case SizeModeSI:
+		output = ByteCountSI(count)
+		break
+	case SizeModeIEC:
+		output = ByteCountIEC(count)
+		break
+	case SizeModeStd:
+		fallthrough
+	default:
+		output = AddThousands(count, ',')
+	}
+	return output
+}
+
 // Byte count formatted using International System (1K = 1000)
 func ByteCountSI(b int64) string {
 	const UNIT = 1000

cmd/wiper/wiper.go

@@ -30,6 +30,7 @@ const (
 	FLAG_HELP_ME      string = "This help"
 	FLAG_HELP_CACHE   string = "Erase cache only"
 	FLAG_HELP_PROFILE string = "Erase profile junk only"
+	FLAG_HELP_SIZE    string = "Select size reporting mode (Std, SI, IEC)"
 	FLAG_HELP_LOG     string = "Enable log output"
 )
 
@@ -51,7 +52,8 @@ var (
  *-----------------------------------------------------------------*/
 
 type BrowserWipe struct {
-	cleaner browsers.IBrowsers
+	cleaner  browsers.IBrowsers
+	SizeMode cmn.SizeMode
 }
 
 /* ----------------------------------------------------------------
@@ -72,16 +74,16 @@ func (b *BrowserWipe) Scan() {
 	}
 
 	for _, br := range supportedBrowsers {
-		b.GetCleaner(br, "")
+		b.GetCleaner(br, "", b.SizeMode)
 		b.cleaner.Tell()
 		installed := b.cleaner.IdentifyAppDataRoot()
 		fmt.Printf("\tInstalled: %t\n", installed)
 	}
 }
 
-func (b *BrowserWipe) GetCleaner(which browsers.Browser, profile string) error {
+func (b *BrowserWipe) GetCleaner(which browsers.Browser, profile string, mode cmn.SizeMode) error {
 	if which == browsers.ChromiumBrowser {
-		b.cleaner = chromium.NewChromiumCleaner(profile, cmn.SizeModeIEC, logx)
+		b.cleaner = chromium.NewChromiumCleaner(profile, mode, logx)
 		return nil
 	}
 
@@ -128,6 +130,7 @@ func help() {
 	fmt.Printf(HELP_TEMPLATE, "-c", "-cache", "", FLAG_HELP_CACHE)
 	fmt.Printf(HELP_TEMPLATE, "-p", "-profile", "", FLAG_HELP_PROFILE)
 	fmt.Printf(HELP_TEMPLATE, "-b", "-browser", "BROWSER", FLAG_HELP_BROWSER)
+	fmt.Printf(HELP_TEMPLATE, "-z", "-size", "Std", FLAG_HELP_SIZE)
 	fmt.Printf(HELP_TEMPLATE, "-s", "-scan", "", FLAG_HELP_SCAN)
 	fmt.Printf(HELP_TEMPLATE, "", "-log", "", FLAG_HELP_LOG)
 
@@ -155,7 +158,7 @@ func die(exitCode int, msgformat string, v ...any) {
 // Usage: wipechromium -p 'Profile 1'
 func main() {
 	// A. Command-line options
-	var profile, browserName string
+	var profile, browserName, szmodeS string
 	var cacheOnly, profileOnly, logging, scanOnly, helpme bool
 	flag.StringVar(&browserName, "b", browsers.ChromiumBrowser.String(), FLAG_HELP_BROWSER)
 	flag.StringVar(&browserName, "browser", browsers.ChromiumBrowser.String(), FLAG_HELP_BROWSER)
@@ -169,6 +172,8 @@ func main() {
 	flag.BoolVar(&cacheOnly, "cache", false, FLAG_HELP_CACHE)
 	flag.BoolVar(&profileOnly, "p", false, FLAG_HELP_PROFILE)
 	flag.BoolVar(&profileOnly, "profile", false, FLAG_HELP_PROFILE)
+	flag.StringVar(&szmodeS, "size", "Std", FLAG_HELP_SIZE)
+	flag.StringVar(&szmodeS, "z", "Std", FLAG_HELP_SIZE)
 	flag.BoolVar(&logging, "log", false, FLAG_HELP_LOG)
 	flag.Parse()
 
@@ -202,29 +207,47 @@ func main() {
 		die(2, "Not a supported browser %q", browserName)
 	}
 
-	// (b.5) Conditional Logging
+	// (b.5) Size reporting mode
+	var sizeMode cmn.SizeMode
+	switch strings.ToLower(szmodeS) {
+	case "si":
+		sizeMode = cmn.SizeModeSI
+		break
+	case "iec":
+		sizeMode = cmn.SizeModeIEC
+		break
+	case "std":
+		sizeMode = cmn.SizeModeStd
+		break
+	default:
+		die(3, "Invalid size mode (SI|IEC|STD) %q", szmodeS)
+	}
+
+	// (b.6) Conditional Logging
 	logx = cmn.NewConditionalLogger(logging, "Main")
 
-	// (b.6) Prologue
+	// (b.7) Prologue
 	if !scanOnly {
 		fmt.Printf("Browser name  : %s\n", browser)
 		fmt.Printf("Profile name  : %s\n", profile)
 		fmt.Printf("Erase cache   : %t\n", cacheOnly)
 		fmt.Printf("Erase profile : %t\n", profileOnly)
+		fmt.Printf("Size mode     : %s\n", sizeMode)
 		fmt.Printf("Logging enable: %t\n", logging)
 	}
 
 	// C. Execute
 	runner := &BrowserWipe{}
+	runner.SizeMode = sizeMode
 	if scanOnly {
 		runner.Scan()
 	} else {
-		if err := runner.GetCleaner(browser, profile); err == nil {
+		if err := runner.GetCleaner(browser, profile, sizeMode); err == nil {
 			if code, err := runner.Run(cacheOnly, profileOnly); err != nil {
 				die(code, err.Error())
 			}
 		} else {
-			die(3, err.Error())
+			die(4, err.Error())
 		}
 	}
 

dircleaner.go

@@ -17,12 +17,6 @@ import (
  *							G l o b a l s
  *-----------------------------------------------------------------*/
 
-const (
-	SizeModeStd SizeMode = iota // full numeric size
-	SizeModeSI                  // Sistema Internacional: 1KB = 1000
-	SizeModeIEC                 // Binary System: 1KB = 1024
-)
-
 var _ IDirCleaner = (*DirCleaner)(nil)
 
 /* ----------------------------------------------------------------
@@ -44,48 +38,35 @@ type DirCleaner struct {
 	cleanedSize int64
 	removedQty  int
 	skippedQty  int
+	sizeMode    SizeMode
 	logx        ILogger
 }
 
-type SizeMode uint
-
 /* ----------------------------------------------------------------
  *							C o n s t r u c t o r s
  *-----------------------------------------------------------------*/
 
-func NewDirCleaner(root string, logger ...ILogger) *DirCleaner {
+func NewDirCleaner(root string, sizing SizeMode, logger ...ILogger) *DirCleaner {
 	const cName = "DirCleaner"
 	var logCtx ILogger
 	if len(logger) == 0 {
 		logCtx = NewConditionalLogger(false, cName)
 	} else {
 		logCtx = logger[0].InheritAs(cName)
 	}
-	return &DirCleaner{root, 0, 0, 0, logCtx}
+	return &DirCleaner{root, 0, 0, 0, sizing, logCtx}
 }
 
 /* ----------------------------------------------------------------
  *							M e t h o d s
  *-----------------------------------------------------------------*/
 
-func (s SizeMode) String() string {
-	switch s {
-	case SizeModeStd:
-		return "Standard"
-	case SizeModeSI:
-		return "International"
-	case SizeModeIEC:
-		return "Binary"
-	default:
-		panic("Unknown size mode")
-	}
-}
-
+// Stringer interface
 func (d *DirCleaner) String() string {
 	return fmt.Sprintf("DirCleaner %q del:%d skip:%d size:%s", d.Root,
 		d.removedQty,
 		d.skippedQty,
-		AddThousands(d.cleanedSize, ','))
+		ReportByteCount(d.cleanedSize, d.sizeMode))
 }
 
 func (d *DirCleaner) CleanUp(exceptions []string) error {

sizemode.go

@@ -0,0 +1,66 @@
+/* -----------------------------------------------------------------
+ *					L o r d  O f   S c r i p t s (tm)
+ *				  Copyright (C)2024 Dídimo Grimaldo T.
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * Size Reporting Mode enumeration
+ *-----------------------------------------------------------------*/
+package wipechromium
+
+import (
+	"errors"
+)
+
+/* ----------------------------------------------------------------
+ *							G l o b a l s
+ *-----------------------------------------------------------------*/
+
+const (
+	SizeModeStd SizeMode = iota // full numeric size
+	SizeModeSI                  // Sistema Internacional: 1KB = 1000
+	SizeModeIEC                 // Binary System: 1KB = 1024
+)
+
+var (
+	ErrUnknownSizeMode = errors.New("Unknown size mode (Std|SI|IEC")
+)
+
+/* ----------------------------------------------------------------
+ *							T y p e s
+ *-----------------------------------------------------------------*/
+
+type SizeMode uint
+
+/* ----------------------------------------------------------------
+ *							C o n s t r u c t o r s
+ *-----------------------------------------------------------------*/
+
+/* ----------------------------------------------------------------
+ *							M e t h o d s
+ *-----------------------------------------------------------------*/
+
+// Stringer interface
+func (s SizeMode) String() string {
+	switch s {
+	case SizeModeStd:
+		return "Standard"
+	case SizeModeSI:
+		return "International"
+	case SizeModeIEC:
+		return "Binary"
+	default:
+		panic(ErrUnknownSizeMode)
+	}
+}
+
+func (s SizeMode) ShortString() string {
+	switch s {
+	case SizeModeStd:
+		return "Std"
+	case SizeModeSI:
+		return "SI"
+	case SizeModeIEC:
+		return "IEC"
+	default:
+		panic(ErrUnknownSizeMode)
+	}
+}