cleanup duplicate code

there is a boolean converter already, using that instead of adding another one.

Author: sni

docs/checks/commands/check_tasksched.md

@@ -56,11 +56,11 @@ Naemon Config
 
 | Argument  | Description                                                                                               |
 | --------- | --------------------------------------------------------------------------------------------------------- |
-| folder    | The folder where the scheduled task is saved. This is used for exact matches, unless recurisive option is enabled. Default: '\' |
+| folder    | The folder where the scheduled task is saved. This is used for exact matches, unless recursive option is enabled. Default: '\' |
 | hidden    | Include hidden tasks. Default: 'false'                                                                    |
 | recursive | Include the subfolders of the specified folder as well when searching for scheduled tasks. Default: 'true' |
 | timezone  | Sets the timezone for time metrics (default is local time)                                                |
-| title     | Sets the task to check. This corresonds to the title of the scheduled task. Default: '\*'                 |
+| title     | Sets the task to check. This corresponds to the title of the scheduled task. Default: '\*'                |
 
 ## Attributes
 

pkg/convert/convert.go

@@ -244,9 +244,9 @@ func BoolE(raw any) (bool, error) {
 		return val, nil
 	default:
 		switch strings.ToLower(fmt.Sprintf("%v", raw)) {
-		case "1", "enable", "enabled", "true", "yes", "on":
+		case "1", "enable", "enabled", "true", "t", "yes", "y", "on":
 			return true, nil
-		case "0", "disable", "disabled", "false", "no", "off":
+		case "0", "disable", "disabled", "false", "f", "no", "n", "off":
 			return false, nil
 		}
 	}

pkg/snclient/check_drivesize.go

@@ -114,7 +114,7 @@ func (l *CheckDrivesize) Build() *CheckData {
 			{name: "drive_or_id", description: "Drive letter if present if not use id"},
 			{name: "drive_or_name", description: "Drive letter if present if not use name"},
 			{name: "fstype", description: "Filesystem type"},
-			{name: "mounted", description: "Flag whether drive is mounter (0/1)"},
+			{name: "mounted", description: "Flag whether drive is mounter (0/1)", unit: UBool},
 
 			{name: "free", description: "Free (human readable) bytes", unit: UByte},
 			{name: "free_bytes", description: "Number of free bytes", unit: UByte},
@@ -141,14 +141,14 @@ func (l *CheckDrivesize) Build() *CheckData {
 
 			{name: "media_type", description: "Windows only: numeric media type of drive"},
 			{name: "type", description: "Windows only: type of drive, ex.: fixed, cdrom, ramdisk, remote, removable, unknown"},
-			{name: "readable", description: "Windows only: flag drive is readable (0/1)"},
-			{name: "writable", description: "Windows only: flag drive is writable (0/1)"},
-			{name: "removable", description: "Windows only: flag drive is removable (0/1)"},
-			{name: "erasable", description: "Windows only: flag whether if drive is erasable (0/1)"},
-			{name: "hotplug", description: "Windows only: flag drive is hotplugable (0/1)"},
+			{name: "readable", description: "Windows only: flag drive is readable (0/1)", unit: UBool},
+			{name: "writable", description: "Windows only: flag drive is writable (0/1)", unit: UBool},
+			{name: "removable", description: "Windows only: flag drive is removable (0/1)", unit: UBool},
+			{name: "erasable", description: "Windows only: flag whether if drive is erasable (0/1)", unit: UBool},
+			{name: "hotplug", description: "Windows only: flag drive is hotplugable (0/1)", unit: UBool},
 
 			{name: "remote_name", description: "Windows only: the remote name of the drive, if it uses a network name"},
-			{name: "persistent", description: "Windows only: if the network drive is mounted as persistent (0/1)"},
+			{name: "persistent", description: "Windows only: if the network drive is mounted as persistent (0/1)", unit: UBool},
 			{name: "localised_remote_path", description: "Windows only: If the path is given as a remote path, and that remote path has an assigned logical drive," +
 				" this is the replaced path under that logical drive."},
 		},

pkg/snclient/check_tasksched.go

@@ -45,11 +45,11 @@ func (l *CheckTasksched) Build() *CheckData {
 			"timezone": {description: "Sets the timezone for time metrics (default is local time)"},
 			"title": {
 				value:       &l.TaskTitle,
-				description: fmt.Sprintf("Sets the task to check. This corresonds to the title of the scheduled task. Default: '%s'", CheckTaskschedDefaultTaskTitle),
+				description: fmt.Sprintf("Sets the task to check. This corresponds to the title of the scheduled task. Default: '%s'", CheckTaskschedDefaultTaskTitle),
 			},
 			"folder": {
 				value: &l.Folder,
-				description: fmt.Sprintf("The folder where the scheduled task is saved. This is used for exact matches, unless recurisive option is enabled. Default: '%s'",
+				description: fmt.Sprintf("The folder where the scheduled task is saved. This is used for exact matches, unless recursive option is enabled. Default: '%s'",
 					CheckTaskschedDefaultFolder),
 			},
 			"recursive": {

pkg/snclient/condition.go

@@ -16,10 +16,6 @@ import (
 )
 
 var (
-	// ^ and $ are used to capture the whole string
-	// (\-?\d+\.\d+|\-?\d+) -> capture group one, two options separated by | first is a decimal with dot , second is a direct number
-	// \s* -> any number of whitespace between the second group
-	// (\D+) -> capture group two, one or more non-digit characters
 	reConditionValueUnit = regexp.MustCompile(`^(\-?\d+\.\d+|\-?\d+)\s*(\D+)$`)
 	reCuddleKeyword      = regexp.MustCompile(`^([A-Za-z_]+)([!=><~]+)(.*)$`)
 	reCuddleOperator     = regexp.MustCompile(`^([!=><~]+)(.*?)$`)
@@ -466,6 +462,8 @@ func (c *Condition) compareEmpty() bool {
 // tries keyword_pct for % unit and keyword_bytes for B unit
 // returns value from keyword unless found already
 func (c *Condition) getVarValue(data map[string]string) (varStr string, ok bool) {
+	unit := c.getUnit(c.keyword)
+
 	switch {
 	case c.unit == "%":
 		varStr, ok = data[c.keyword+"_pct"]
@@ -486,6 +484,18 @@ func (c *Condition) getVarValue(data map[string]string) (varStr string, ok bool)
 
 	varStr, ok = data[c.keyword]
 
+	if ok && unit == UBool {
+		valBool, err := convert.BoolE(varStr)
+		if err != nil {
+			log.Errorf("condition based on non-bool value: %s", err.Error())
+		}
+		if valBool {
+			return "true", true
+		}
+
+		return "false", true
+	}
+
 	return varStr, ok
 }
 
@@ -833,13 +843,11 @@ func (c *Condition) expandUnitByType(str string) error {
 	case UBool:
 		// boolean units are not in the form of '<number> <unit>'
 		// need to handle them before regex condition checks.
-		newVal, oldVal, err := utils.ParseAndReplaceBoolAttributes(str)
+		newVal, err := convert.BoolE(str)
 		if err != nil {
 			return fmt.Errorf("invalid boolean value: %s", err.Error())
 		}
-		c.original = oldVal
 		c.value = newVal
-		c.unit = ""
 
 		return nil
 	default:

pkg/snclient/condition_test.go

@@ -91,6 +91,31 @@ func TestConditionStrings(t *testing.T) {
 	}
 }
 
+func TestConditionBool(t *testing.T) {
+	for _, check := range []struct {
+		key           string
+		value         string
+		condition     string
+		expect        bool
+		deterministic bool
+	}{
+		{"mounted", "1", "mounted = 1", true, true},
+		{"mounted", "0", "mounted = 1", false, true},
+		{"mounted", "0", "mounted = 0", true, true},
+		{"mounted", "1", "mounted = true", true, true},
+		{"mounted", "0", "mounted = true", false, true},
+		{"mounted", "0", "mounted = false", true, true},
+	} {
+		cond, err := NewCondition(check.condition, &[]CheckAttribute{{name: "mounted", unit: UBool}})
+		require.NoError(t, err)
+
+		compare := map[string]string{check.key: check.value}
+		res, ok := cond.Match(compare)
+		assert.Equalf(t, check.expect, res, "Compare(%s) -> (%v) %v", check.condition, check.value, check.expect)
+		assert.Equalf(t, check.deterministic, ok, "Compare(%s) -> determined: (%v) %v", check.condition, check.value, check.deterministic)
+	}
+}
+
 func TestConditionParseErrors(t *testing.T) {
 	for _, check := range []struct {
 		threshold string

pkg/utils/utils.go

@@ -81,67 +81,6 @@ func ExpandDuration(val string) (res float64, err error) {
 	return 0, fmt.Errorf("expandDuration: cannot parse duration, unknown format in %s", val)
 }
 
-var (
-	truthyValues = []string{"1", "true", "enabled", "yes", "y", "on", "t"}
-	falseyValues = []string{"0", "false", "disabled", "no", "n", "off", "f"}
-)
-
-var (
-	truthyRegex, truthyReplacements = replacePatterns(truthyValues, "true")
-	falseyRegex, falseyReplacements = replacePatterns(falseyValues, "false")
-)
-
-// replacePatterns builds a regex that matches any of the given words as whole words,
-// and returns the pattern and a replacement map (lowercase match → replacement).
-func replacePatterns(words []string, replacement string) (regex *regexp.Regexp, replacements map[string]string) {
-	escaped := make([]string, len(words))
-	replacementMap := make(map[string]string)
-	for i, word := range words {
-		lowercase := strings.ToLower(word)
-		escaped[i] = regexp.QuoteMeta(lowercase)
-		replacementMap[lowercase] = replacement
-	}
-	pattern := `(?i)\b(` + strings.Join(escaped, "|") + `)\b`
-
-	return regexp.MustCompile(pattern), replacementMap
-}
-
-// ParseAndReplaceBoolAttributes replaces all known truthy/falsey tokens in val
-// with "true"/"false" (case‑insensitive whole‑word match).
-// Returns the modified string, the original string, and an error if any
-// unrecognized boolean‑like token is found (optional).
-func ParseAndReplaceBoolAttributes(val string) (newVal, oldVal string, err error) {
-	oldVal = val
-	foundValues := 0
-
-	newVal = truthyRegex.ReplaceAllStringFunc(val, func(match string) string {
-		if replacement, ok := truthyReplacements[strings.ToLower(match)]; ok {
-			foundValues++
-
-			return replacement
-		}
-
-		return ""
-	})
-
-	newVal = falseyRegex.ReplaceAllStringFunc(newVal, func(match string) string {
-		if replacement, ok := falseyReplacements[strings.ToLower(match)]; ok {
-			foundValues++
-
-			return replacement
-		}
-
-		return ""
-	})
-
-	if foundValues == 0 {
-		err = fmt.Errorf("attribute of type bool can not be parsed: '%s' needs to be one of '%s' or '%s'",
-			val, strings.Join(falseyValues, " "), strings.Join(truthyValues, " "))
-	}
-
-	return newVal, oldVal, err
-}
-
 // returns time/duration in target unit with given precision
 func TimeUnitF(num uint64, targetUnit string, precision int) float64 {
 	for _, factor := range TimeFactors {