chore: refactor include/exclude config (#15)

Author: Hanaasagi

cmd/magonote/config.go

@@ -9,7 +9,7 @@ import (
 
 type Config struct {
 	Core    CoreConfig    `toml:"core"`
-	Regexp  RegexpConfig  `toml:"regexp"`
+	Rules   RulesConfig   `toml:"rules"`
 	Colors  ColorConfig   `toml:"colors"`
 	Plugins PluginsConfig `toml:"plugins"`
 }
@@ -24,8 +24,16 @@ type CoreConfig struct {
 	Contrast    bool   `toml:"contrast"`
 }
 
-type RegexpConfig struct {
-	Patterns []string `toml:"patterns"`
+// RulesConfig unifies user-defined include (match) and exclude (filter) rules
+// Both include and exclude carry a "rules" list with items of the same shape: { type, pattern }
+type RulesConfig struct {
+	Include RulesList `toml:"include"`
+	Exclude RulesList `toml:"exclude"`
+}
+
+// RulesList groups a list of rules under a section
+type RulesList struct {
+	Rules []Rule `toml:"rules"`
 }
 
 type ColorGroup struct {
@@ -51,20 +59,15 @@ type ColorDetectionPluginConfig struct {
 	Enabled bool `toml:"enabled"`
 }
 
-type ExclusionRule struct {
+// Rule describes a single rule item used in include/exclude lists
+type Rule struct {
 	Type    string `toml:"type"`    // "regex" or "text"
 	Pattern string `toml:"pattern"` // The pattern or text to exclude
 }
 
-type ExclusionConfig struct {
-	Enabled bool            `toml:"enabled"`
-	Rules   []ExclusionRule `toml:"rules"`
-}
-
 type PluginsConfig struct {
 	Tabledetection *TableDetectionPluginConfig `toml:"tabledetection"`
 	Colordetection *ColorDetectionPluginConfig `toml:"colordetection"`
-	Exclusion      *ExclusionConfig            `toml:"exclusion"`
 }
 
 func NewDefaultConfig() *Config {
@@ -78,9 +81,7 @@ func NewDefaultConfig() *Config {
 			UniqueLevel: 0,
 			Contrast:    false,
 		},
-		Regexp: RegexpConfig{
-			Patterns: []string{},
-		},
+		Rules: RulesConfig{Include: RulesList{Rules: []Rule{}}, Exclude: RulesList{Rules: []Rule{}}},
 		Colors: ColorConfig{
 			Match: ColorGroup{
 				Foreground: "green",
@@ -102,7 +103,6 @@ func NewDefaultConfig() *Config {
 		Plugins: PluginsConfig{
 			Tabledetection: nil,
 			Colordetection: nil,
-			Exclusion:      nil,
 		},
 	}
 }
@@ -117,6 +117,5 @@ func LoadConfigFromFile(path string) (*Config, error) {
 	if _, err := toml.DecodeFile(path, config); err != nil {
 		return nil, fmt.Errorf("failed to decode TOML config: %w", err)
 	}
-
 	return config, nil
 }

cmd/magonote/main.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"runtime/debug"
 	"strings"
 
@@ -232,7 +233,11 @@ func applyCliOverrides(cmd *cobra.Command, config *Config, args *Arguments) {
 	}
 
 	if len(args.regexpPatterns) > 0 {
-		config.Regexp.Patterns = args.regexpPatterns
+		// CLI `--regexp` only accepts regex strings, map them into include rules
+		config.Rules.Include.Rules = make([]Rule, 0, len(args.regexpPatterns))
+		for _, p := range args.regexpPatterns {
+			config.Rules.Include.Rules = append(config.Rules.Include.Rules, Rule{Type: "regex", Pattern: p})
+		}
 	}
 
 	if cmd.Flags().Changed("fg-color") {
@@ -275,17 +280,14 @@ func applyCliOverrides(cmd *cobra.Command, config *Config, args *Arguments) {
 
 	// Handle extra exclusion patterns from CLI
 	if len(args.extraExclusion) > 0 {
-		if config.Plugins.Exclusion == nil {
-			config.Plugins.Exclusion = &ExclusionConfig{Enabled: true, Rules: []ExclusionRule{}}
-		}
-		// Add CLI exclusion patterns as text rules
+		// Add CLI exclusion patterns as regex rules into unified rules.exclude
 		for _, pattern := range args.extraExclusion {
-			config.Plugins.Exclusion.Rules = append(config.Plugins.Exclusion.Rules, ExclusionRule{
-				Type:    "text",
-				Pattern: pattern,
-			})
+			if _, err := regexp.Compile(pattern); err != nil {
+				slog.Warn("Invalid regex in --extra-exclusion; skipping", "pattern", pattern, "error", err)
+				continue
+			}
+			config.Rules.Exclude.Rules = append(config.Rules.Exclude.Rules, Rule{Type: "regex", Pattern: pattern})
 		}
-		config.Plugins.Exclusion.Enabled = true
 	}
 }
 
@@ -297,7 +299,14 @@ func runApp(config *Config, args *Arguments) error {
 		return err
 	}
 
-	state := internal.NewState(text, config.Core.Alphabet, config.Regexp.Patterns)
+	// Convert include rules to regex patterns list
+	var includePatterns []string
+	for _, r := range config.Rules.Include.Rules {
+		if r.Type == "regex" && r.Pattern != "" {
+			includePatterns = append(includePatterns, r.Pattern)
+		}
+	}
+	state := internal.NewState(text, config.Core.Alphabet, includePatterns)
 
 	plugins := config.Plugins
 	if plugins.Tabledetection != nil && plugins.Tabledetection.Enabled {
@@ -312,14 +321,11 @@ func runApp(config *Config, args *Arguments) error {
 		state.ColorDetectionConfig = internal.NewColorDetectionConfig()
 	}
 
-	if plugins.Exclusion != nil && plugins.Exclusion.Enabled {
-		// Convert config exclusion rules to internal exclusion rules
+	// Apply user-defined exclusion rules (unified rules section)
+	if len(config.Rules.Exclude.Rules) > 0 {
 		var rules []internal.ExclusionRule
-		for _, rule := range plugins.Exclusion.Rules {
-			rules = append(rules, internal.ExclusionRule{
-				Type:    rule.Type,
-				Pattern: rule.Pattern,
-			})
+		for _, rule := range config.Rules.Exclude.Rules {
+			rules = append(rules, internal.ExclusionRule{Type: rule.Type, Pattern: rule.Pattern})
 		}
 		state.ExclusionConfig = internal.NewExclusionConfig(rules)
 	}
@@ -446,7 +452,7 @@ func main() {
 	rootCmd.Flags().StringVarP(&args.target, "target", "t", "", "Stores the hint in the specified path")
 	rootCmd.Flags().StringVarP(&args.inputFile, "input-file", "i", "", "Read input from file instead of stdin")
 	rootCmd.Flags().BoolVarP(&args.showVersion, "version", "v", false, "Print version and exit")
-	rootCmd.Flags().StringArrayVar(&args.extraExclusion, "extra-exclusion", nil, "Additional text patterns to exclude from matching")
+	rootCmd.Flags().StringArrayVar(&args.extraExclusion, "extra-exclusion", nil, "Additional regex patterns to exclude from matching")
 
 	rootCmd.Flags().BoolVar(&args.listView, "list", false, "Enable list view")
 

config.example.toml

@@ -8,7 +8,7 @@ alphabet = "qwerty"
 # Output format for the picked hint (%H = hint text, %U = uppercase flag)
 format = "%H"
 
-# Hint position: "left" or "right"
+# Hint position: "left", "right", "off_left", or "off_right"
 position = "left"
 
 # Enable multi-selection mode
@@ -23,12 +23,14 @@ unique_level = 0
 # Put square brackets around hint for visibility
 contrast = false
 
-[regexp]
-# Additional regex patterns to match
-patterns = [
-    # Example patterns (uncomment to use)
-    # "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b",  # Email
-    # "\\bhttps?://[\\w.-]+\\b",  # URL
+[rules]
+# User-defined matching and filtering rules
+
+[rules.include]
+# Additional rules to match. Only { type = "regex" } is honored here.
+rules = [
+    # { type = "regex", pattern = "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b" },  # Email
+    # { type = "regex", pattern = "\\bhttps?://[\\w.-]+\\b" },                                 # URL
 ]
 
 [colors.match]
@@ -64,23 +66,22 @@ confidence_threshold = 0.8
 [plugins.colordetection]
 enabled = true
 
-[plugins.exclusion]
-enabled = false
+[rules.exclude]
 # Exclusion rules to filter out unwanted matches by defining regions in the original text
 # The rules first identify exclusion regions in the input text, then filter out any matches
 # whose coordinates overlap with these regions
 rules = [
-    # Example: Exclude entire shell prompt lines (automatically configured by tmux integration)
-    # { type = "regex", pattern = "^user@hostname:.*\\$ " },  # Exclude entire lines starting with prompt
-    # { type = "text", pattern = "~/project$ " },             # Exclude specific prompt text
+    # Example: Exclude entire shell prompt lines
+    # { type = "regex", pattern = "^user@hostname:.*\\$ " },  # Lines starting with prompt
+    # { type = "text", pattern = "~/project$ " },             # Specific prompt fragment
 
     # Additional examples:
-    # { type = "text", pattern = "DEBUG" },                   # Exclude matches in regions containing "DEBUG"
-    # { type = "regex", pattern = "^\\[.*\\]\\$ " },         # Exclude bracketed prompts like "[user@host]$ "
-    # { type = "regex", pattern = "^\\d{4}-\\d{2}-\\d{2}" }, # Exclude regions starting with dates
-    # { type = "regex", pattern = "Error:.*" },              # Exclude entire error message lines
+    # { type = "text", pattern = "DEBUG" },                   # Regions containing "DEBUG"
+    # { type = "regex", pattern = "^\\[.*\\]\\$ " },         # Bracketed prompts like "[user@host]$ "
+    # { type = "regex", pattern = "^\\d{4}-\\d{2}-\\d{2}" }, # Lines starting with dates
+    # { type = "regex", pattern = "Error:.*" },              # Entire error message lines
 
     # Exclude log timestamps and noise:
-    # { type = "regex", pattern = "^\\d{2}:\\d{2}:\\d{2}" }, # Lines starting with timestamps
+    # { type = "regex", pattern = "^\\d{2}:\\d{2}:\\d{2}" }, # Timestamps like 12:34:56
     # { type = "text", pattern = "INFO" },                   # Any region containing INFO logs
 ]