-56

gtk/dialog_helpers.go

Reviewed

··· 74 74 75 75 return dialog, content 76 76 } 77 77 - 78 78 - func conditionTypeToIndex(conditionType string) uint { 79 79 - switch conditionType { 80 80 - case "domain": 81 81 - return 0 82 82 - case "keyword": 83 83 - return 1 84 84 - case "glob": 85 85 - return 2 86 86 - case "regex": 87 87 - return 3 88 88 - default: 89 89 - return 0 90 90 - } 91 91 - } 92 92 - 93 93 - func indexToConditionType(index uint) string { 94 94 - switch index { 95 95 - case 0: 96 96 - return "domain" 97 97 - case 1: 98 98 - return "keyword" 99 99 - case 2: 100 100 - return "glob" 101 101 - case 3: 102 102 - return "regex" 103 103 - default: 104 104 - return "domain" 105 105 - } 106 106 - } 107 107 - 108 108 - func redirectionTypeToIndex(redirectionType string) uint { 109 109 - switch redirectionType { 110 110 - case "wildcard": 111 111 - return 1 112 112 - case "regex": 113 113 - return 2 114 114 - default: 115 115 - return 0 116 116 - } 117 117 - } 118 118 - 119 119 - func indexToRedirectionType(index uint) string { 120 120 - switch index { 121 121 - case 1: 122 122 - return "wildcard" 123 123 - case 2: 124 124 - return "regex" 125 125 - default: 126 126 - return "domain" 127 127 - } 128 128 - } 129 129 - 130 130 - func getRedirectionTypeLabels() []string { 131 131 - return []string{"Domain", "Wildcard", "Regex"} 132 132 - }

+4 -4

gtk/dialog_redirection.go

Reviewed

··· 50 50 51 51 typeRow := adw.NewComboRow() 52 52 typeRow.SetTitle("Type") 53 53 - typeRow.SetModel(gtk.NewStringList(getRedirectionTypeLabels())) 53 53 + typeRow.SetModel(gtk.NewStringList(routing.RedirectionTypeLabels())) 54 54 if !isNew { 55 55 - typeRow.SetSelected(redirectionTypeToIndex(redirection.Type)) 55 55 + typeRow.SetSelected(routing.RedirectionTypeToIndex(redirection.Type)) 56 56 } 57 57 group.Add(typeRow) 58 58 ··· 74 74 75 75 validateInputs := func() { 76 76 find := findRow.Text() 77 77 - redirectionType := indexToRedirectionType(typeRow.Selected()) 77 77 + redirectionType := routing.IndexToRedirectionType(typeRow.Selected()) 78 78 redirection := Redirection{Type: redirectionType, Find: find, Replace: replaceRow.Text()} 79 79 err := routing.ValidateRedirection(redirection) 80 80 ··· 95 95 saveBtn.ConnectClicked(func() { 96 96 name := nameRow.Text() 97 97 find := findRow.Text() 98 98 - redirectionType := indexToRedirectionType(typeRow.Selected()) 98 98 + redirectionType := routing.IndexToRedirectionType(typeRow.Selected()) 99 99 100 100 if isNew { 101 101 cfg.Redirections = append(cfg.Redirections, Redirection{

+4 -4

gtk/dialog_rule_common.go

Reviewed

··· 162 162 conditionContainer.SetMarginEnd(12) 163 163 164 164 typeDropdown := gtk.NewDropDown( 165 165 - gtk.NewStringList([]string{"Exact Domain", "URL Contains", "Wildcard", "Regex"}), 165 165 + gtk.NewStringList(routing.ConditionTypeLabels()), 166 166 nil, 167 167 ) 168 168 - typeDropdown.SetSelected(conditionTypeToIndex((*conditions)[conditionIndex].Type)) 168 168 + typeDropdown.SetSelected(routing.ConditionTypeToIndex((*conditions)[conditionIndex].Type)) 169 169 typeDropdown.SetVAlign(gtk.AlignCenter) 170 170 typeDropdown.SetSizeRequest(150, -1) 171 171 conditionContainer.Append(typeDropdown) ··· 192 192 conditionContainer.Append(patternEntry) 193 193 194 194 typeDropdown.Connect("notify::selected", func() { 195 195 - (*conditions)[conditionIndex].Type = indexToConditionType(typeDropdown.Selected()) 195 195 + (*conditions)[conditionIndex].Type = routing.IndexToConditionType(typeDropdown.Selected()) 196 196 validateConditionEntry(conditions, conditionIndex, typeDropdown, patternEntry, actionButton) 197 197 }) 198 198 ··· 229 229 actionButton *gtk.Button, 230 230 ) { 231 231 pattern := patternEntry.Text() 232 232 - conditionType := indexToConditionType(typeDropdown.Selected()) 232 232 + conditionType := routing.IndexToConditionType(typeDropdown.Selected()) 233 233 234 234 err := routing.ValidateConditionPattern(conditionType, pattern) 235 235 if err != nil {

+2 -19

gtk/run.go

Reviewed

··· 62 62 return 63 63 } 64 64 65 65 - sanitized := prepareURLForRouting(rawURL, cfg) 65 65 + sanitized := routing.PrepareURLForRouting(rawURL, cfg.RemoveTrackingParameters, cfg.Redirections) 66 66 if sanitized == "" { 67 67 // URL was rejected (mailto:, tel:, etc.) - pass to xdg-open 68 68 cmd := host.HostCommand("xdg-open", rawURL) ··· 105 105 return 106 106 } 107 107 108 108 - sanitized := prepareURLForRouting(targetURL, cfg) 108 108 + sanitized := routing.PrepareURLForRouting(targetURL, cfg.RemoveTrackingParameters, cfg.Redirections) 109 109 if sanitized == "" { 110 110 // Pass non-browser URLs to xdg-open 111 111 cmd := host.HostCommand("xdg-open", targetURL) ··· 133 133 134 134 // No browser specified - use standard routing 135 135 handleURL(app, browsers, cfg, sanitized) 136 136 - } 137 137 - 138 138 - func prepareURLForRouting(rawURL string, cfg *Config) string { 139 139 - sanitized := routing.SanitizeURL(rawURL) 140 140 - if sanitized == "" { 141 141 - return "" 142 142 - } 143 143 - 144 144 - if cfg.RemoveTrackingParameters { 145 145 - sanitized = routing.RemoveTrackingParameters(sanitized) 146 146 - } 147 147 - 148 148 - if len(cfg.Redirections) > 0 { 149 149 - sanitized = routing.ApplyRedirections(sanitized, cfg.Redirections) 150 150 - } 151 151 - 152 152 - return sanitized 153 136 } 154 137 155 138 // handleURL routes a URL to the appropriate browser based on rules

+3 -26

gtk/settings_redirections.go

Reviewed

··· 6 6 "fmt" 7 7 "html" 8 8 9 9 + "github.com/alyraffauf/switchyard/internal/routing" 9 10 "github.com/diamondburned/gotk4-adwaita/pkg/adw" 10 11 "github.com/diamondburned/gotk4/pkg/gtk/v4" 11 12 ) 12 12 - 13 13 - func formatRedirectionSubtitle(redirection *Redirection) string { 14 14 - redirectionType := redirection.Type 15 15 - if redirectionType == "" { 16 16 - redirectionType = "domain" 17 17 - } 18 18 - 19 19 - var typeLabel string 20 20 - switch redirectionType { 21 21 - case "domain": 22 22 - typeLabel = "Domain" 23 23 - case "wildcard": 24 24 - typeLabel = "Wildcard" 25 25 - case "regex": 26 26 - typeLabel = "Regex" 27 27 - default: 28 28 - typeLabel = "Domain" 29 29 - } 30 30 - 31 31 - if redirection.Replace == "" { 32 32 - return fmt.Sprintf("%s · Removes match", typeLabel) 33 33 - } 34 34 - return fmt.Sprintf("%s · Replaces with %s", typeLabel, html.EscapeString(redirection.Replace)) 35 35 - } 36 13 37 14 func createRedirectionsPage(win *adw.Window, cfg *Config) gtk.Widgetter { 38 15 toolbarView := adw.NewToolbarView() ··· 79 56 row := adw.NewActionRow() 80 57 if redirection.Name != "" { 81 58 row.SetTitle(redirection.Name) 82 82 - row.SetSubtitle(fmt.Sprintf("%s · %s", html.EscapeString(redirection.Find), formatRedirectionSubtitle(redirection))) 59 59 + row.SetSubtitle(fmt.Sprintf("%s · %s", html.EscapeString(redirection.Find), html.EscapeString(routing.FormatRedirectionSubtitle(redirection)))) 83 60 } else { 84 61 row.SetTitle(redirection.Find) 85 85 - row.SetSubtitle(formatRedirectionSubtitle(redirection)) 62 62 + row.SetSubtitle(html.EscapeString(routing.FormatRedirectionSubtitle(redirection))) 86 63 } 87 64 row.SetActivatable(true) 88 65

+4 -69

gtk/settings_rules.go

Reviewed

··· 3 3 package gtk 4 4 5 5 import ( 6 6 - "fmt" 6 6 + "html" 7 7 8 8 appbrowser "github.com/alyraffauf/switchyard/internal/browser" 9 9 + "github.com/alyraffauf/switchyard/internal/routing" 9 10 "github.com/diamondburned/gotk4-adwaita/pkg/adw" 10 11 "github.com/diamondburned/gotk4/pkg/gtk/v4" 11 12 ) 12 13 13 13 - // formatRuleSubtitle formats a subtitle for a rule row with pattern included 14 14 - func formatRuleSubtitle(rule *Rule, browserName string) string { 15 15 - return formatRuleSubtitleInternal(rule, browserName, true) 16 16 - } 17 17 - 18 18 - // formatRuleSubtitleNoPattern formats a subtitle for a rule row without pattern 19 19 - func formatRuleSubtitleNoPattern(rule *Rule, browserName string) string { 20 20 - return formatRuleSubtitleInternal(rule, browserName, false) 21 21 - } 22 22 - 23 23 - func formatRuleSubtitleInternal(rule *Rule, browserName string, includePattern bool) string { 24 24 - if len(rule.Conditions) > 0 { 25 25 - condCount := len(rule.Conditions) 26 26 - var logicText string 27 27 - if rule.Logic == "any" { 28 28 - logicText = "Any match" 29 29 - } else { 30 30 - logicText = "All match" 31 31 - } 32 32 - 33 33 - formatSingleCondition := func(cond *Condition) string { 34 34 - return fmt.Sprintf("%s %s", getConditionLabel(cond.Type, cond.Negate), cond.Pattern) 35 35 - } 36 36 - 37 37 - if rule.AlwaysAsk { 38 38 - if condCount == 1 && includePattern { 39 39 - return fmt.Sprintf("%s · Always ask", formatSingleCondition(&rule.Conditions[0])) 40 40 - } 41 41 - return fmt.Sprintf("%d conditions (%s) · Always ask", condCount, logicText) 42 42 - } 43 43 - if condCount == 1 && includePattern { 44 44 - return fmt.Sprintf("%s · Opens in %s", formatSingleCondition(&rule.Conditions[0]), browserName) 45 45 - } 46 46 - return fmt.Sprintf("%d conditions (%s) · Opens in %s", condCount, logicText, browserName) 47 47 - } 48 48 - 49 49 - return "No conditions" 50 50 - } 51 51 - 52 52 - func getConditionLabel(patternType string, negate bool) string { 53 53 - switch patternType { 54 54 - case "domain": 55 55 - if negate { 56 56 - return "Domain is not" 57 57 - } 58 58 - return "Domain is" 59 59 - case "keyword": 60 60 - if negate { 61 61 - return "URL does not contain" 62 62 - } 63 63 - return "URL contains" 64 64 - case "glob": 65 65 - if negate { 66 66 - return "Wildcard is not" 67 67 - } 68 68 - return "Wildcard is" 69 69 - case "regex": 70 70 - if negate { 71 71 - return "Regex does not match" 72 72 - } 73 73 - return "Regex matches" 74 74 - default: 75 75 - return patternType 76 76 - } 77 77 - } 78 78 - 79 14 func createRulesPage(win *adw.Window, browsers []*Browser, cfg *Config) gtk.Widgetter { 80 15 toolbarView := adw.NewToolbarView() 81 16 ··· 128 63 row := adw.NewActionRow() 129 64 if rule.Name != "" { 130 65 row.SetTitle(rule.Name) 131 131 - row.SetSubtitle(formatRuleSubtitle(rule, getBrowserName(rule.Browser))) 66 66 + row.SetSubtitle(html.EscapeString(routing.FormatRuleSubtitle(rule, getBrowserName(rule.Browser)))) 132 67 } else { 133 68 if len(rule.Conditions) > 0 { 134 69 row.SetTitle(rule.Conditions[0].Pattern) 135 70 } 136 136 - row.SetSubtitle(formatRuleSubtitleNoPattern(rule, getBrowserName(rule.Browser))) 71 71 + row.SetSubtitle(html.EscapeString(routing.FormatRuleSubtitleNoPattern(rule, getBrowserName(rule.Browser)))) 137 72 } 138 73 row.SetActivatable(true) 139 74

+187

internal/routing/format.go

Reviewed

··· 1 1 + // SPDX-License-Identifier: GPL-3.0-or-later 2 2 + 3 3 + package routing 4 4 + 5 5 + import "fmt" 6 6 + 7 7 + // --- Condition types: single source of truth --- 8 8 + 9 9 + // conditionTypeDef is the single source of truth for a condition type: 10 10 + // its combo-box label, and the labels used in rule subtitles. 11 11 + type conditionTypeDef struct { 12 12 + Type string 13 13 + Label string // combo-box dropdown label 14 14 + MatchLabel string // e.g. "Domain is" 15 15 + NegateLabel string // e.g. "Domain is not" 16 16 + } 17 17 + 18 18 + // conditionTypes is the ordered list of supported condition types. 19 19 + // Index order is the combo-box order; adding a type here is sufficient 20 20 + // for all mappers, dropdown models, and condition labels. 21 21 + var conditionTypes = []conditionTypeDef{ 22 22 + {Type: "domain", Label: "Exact Domain", MatchLabel: "Domain is", NegateLabel: "Domain is not"}, 23 23 + {Type: "keyword", Label: "URL Contains", MatchLabel: "URL contains", NegateLabel: "URL does not contain"}, 24 24 + {Type: "glob", Label: "Wildcard", MatchLabel: "Wildcard is", NegateLabel: "Wildcard is not"}, 25 25 + {Type: "regex", Label: "Regex", MatchLabel: "Regex matches", NegateLabel: "Regex does not match"}, 26 26 + } 27 27 + 28 28 + // ConditionTypeToIndex maps a condition type string to its combo-box index. 29 29 + func ConditionTypeToIndex(conditionType string) uint { 30 30 + for i, def := range conditionTypes { 31 31 + if def.Type == conditionType { 32 32 + return uint(i) 33 33 + } 34 34 + } 35 35 + return 0 36 36 + } 37 37 + 38 38 + // IndexToConditionType maps a combo-box index to its condition type string. 39 39 + func IndexToConditionType(index uint) string { 40 40 + if int(index) < len(conditionTypes) { 41 41 + return conditionTypes[index].Type 42 42 + } 43 43 + return conditionTypes[0].Type 44 44 + } 45 45 + 46 46 + // ConditionTypeLabels returns the human-readable labels for condition types. 47 47 + func ConditionTypeLabels() []string { 48 48 + labels := make([]string, len(conditionTypes)) 49 49 + for i, def := range conditionTypes { 50 50 + labels[i] = def.Label 51 51 + } 52 52 + return labels 53 53 + } 54 54 + 55 55 + // --- Redirection types --- 56 56 + 57 57 + // redirectionTypeDef describes a redirection type for UI dropdowns and mappers. 58 58 + type redirectionTypeDef struct { 59 59 + Type string 60 60 + Label string 61 61 + } 62 62 + 63 63 + // redirectionTypes is the ordered list of supported redirection types. 64 64 + var redirectionTypes = []redirectionTypeDef{ 65 65 + {Type: "domain", Label: "Domain"}, 66 66 + {Type: "wildcard", Label: "Wildcard"}, 67 67 + {Type: "regex", Label: "Regex"}, 68 68 + } 69 69 + 70 70 + // RedirectionTypeToIndex maps a redirection type string to its combo-box index. 71 71 + func RedirectionTypeToIndex(redirectionType string) uint { 72 72 + for i, def := range redirectionTypes { 73 73 + if def.Type == redirectionType { 74 74 + return uint(i) 75 75 + } 76 76 + } 77 77 + return 0 78 78 + } 79 79 + 80 80 + // IndexToRedirectionType maps a combo-box index to its redirection type string. 81 81 + func IndexToRedirectionType(index uint) string { 82 82 + if int(index) < len(redirectionTypes) { 83 83 + return redirectionTypes[index].Type 84 84 + } 85 85 + return redirectionTypes[0].Type 86 86 + } 87 87 + 88 88 + // RedirectionTypeLabels returns the human-readable labels for redirection types. 89 89 + func RedirectionTypeLabels() []string { 90 90 + labels := make([]string, len(redirectionTypes)) 91 91 + for i, def := range redirectionTypes { 92 92 + labels[i] = def.Label 93 93 + } 94 94 + return labels 95 95 + } 96 96 + 97 97 + // NormalizeRedirectionType returns the canonical redirection type string, 98 98 + // defaulting empty to "domain". Unknown non-empty types are returned as-is 99 99 + // so callers can detect and handle them. 100 100 + func NormalizeRedirectionType(typ string) string { 101 101 + if typ == "" { 102 102 + return "domain" 103 103 + } 104 104 + return typ 105 105 + } 106 106 + 107 107 + // RedirectionTypeLabel returns the human-readable label for a redirection type. 108 108 + // Falls back to the raw type string for unknown types. 109 109 + func RedirectionTypeLabel(typ string) string { 110 110 + typ = NormalizeRedirectionType(typ) 111 111 + for _, def := range redirectionTypes { 112 112 + if def.Type == typ { 113 113 + return def.Label 114 114 + } 115 115 + } 116 116 + return typ 117 117 + } 118 118 + 119 119 + // --- Rule / condition formatting (plain text, no markup) --- 120 120 + 121 121 + // FormatRuleSubtitle returns a plain-text subtitle for a rule row with the 122 122 + // condition pattern included. Callers must escape the result before passing 123 123 + // it to a widget that parses markup. 124 124 + func FormatRuleSubtitle(rule *Rule, browserName string) string { 125 125 + return formatRuleSubtitle(rule, browserName, true) 126 126 + } 127 127 + 128 128 + // FormatRuleSubtitleNoPattern is like FormatRuleSubtitle but omits the 129 129 + // condition pattern from the result. 130 130 + func FormatRuleSubtitleNoPattern(rule *Rule, browserName string) string { 131 131 + return formatRuleSubtitle(rule, browserName, false) 132 132 + } 133 133 + 134 134 + func formatRuleSubtitle(rule *Rule, browserName string, includePattern bool) string { 135 135 + if len(rule.Conditions) == 0 { 136 136 + return "No conditions" 137 137 + } 138 138 + 139 139 + conditionCount := len(rule.Conditions) 140 140 + var logicText string 141 141 + if rule.Logic == "any" { 142 142 + logicText = "Any match" 143 143 + } else { 144 144 + logicText = "All match" 145 145 + } 146 146 + 147 147 + formatSingleCondition := func(condition *Condition) string { 148 148 + return fmt.Sprintf("%s %s", ConditionLabel(condition.Type, condition.Negate), condition.Pattern) 149 149 + } 150 150 + 151 151 + if rule.AlwaysAsk { 152 152 + if conditionCount == 1 && includePattern { 153 153 + return fmt.Sprintf("%s · Always ask", formatSingleCondition(&rule.Conditions[0])) 154 154 + } 155 155 + return fmt.Sprintf("%d conditions (%s) · Always ask", conditionCount, logicText) 156 156 + } 157 157 + if conditionCount == 1 && includePattern { 158 158 + return fmt.Sprintf("%s · Opens in %s", formatSingleCondition(&rule.Conditions[0]), browserName) 159 159 + } 160 160 + return fmt.Sprintf("%d conditions (%s) · Opens in %s", conditionCount, logicText, browserName) 161 161 + } 162 162 + 163 163 + // ConditionLabel returns a human-readable label for a condition type, 164 164 + // derived from the conditionTypes table. 165 165 + func ConditionLabel(patternType string, negate bool) string { 166 166 + for _, def := range conditionTypes { 167 167 + if def.Type == patternType { 168 168 + if negate { 169 169 + return def.NegateLabel 170 170 + } 171 171 + return def.MatchLabel 172 172 + } 173 173 + } 174 174 + return patternType 175 175 + } 176 176 + 177 177 + // FormatRedirectionSubtitle returns a plain-text subtitle describing a 178 178 + // redirection's type and action. Callers must escape the result before 179 179 + // passing it to a widget that parses markup. 180 180 + func FormatRedirectionSubtitle(redirection *Redirection) string { 181 181 + typeLabel := RedirectionTypeLabel(redirection.Type) 182 182 + 183 183 + if redirection.Replace == "" { 184 184 + return fmt.Sprintf("%s · Removes match", typeLabel) 185 185 + } 186 186 + return fmt.Sprintf("%s · Replaces with %s", typeLabel, redirection.Replace) 187 187 + }

+23

internal/routing/pipeline.go

Reviewed

··· 1 1 + // SPDX-License-Identifier: GPL-3.0-or-later 2 2 + 3 3 + package routing 4 4 + 5 5 + // PrepareURLForRouting runs the full URL processing pipeline: sanitize, 6 6 + // optionally strip tracking parameters, and apply redirections. 7 7 + // Returns "" if the URL was rejected (e.g. mailto:, tel:). 8 8 + func PrepareURLForRouting(rawURL string, removeTracking bool, redirections []Redirection) string { 9 9 + sanitized := SanitizeURL(rawURL) 10 10 + if sanitized == "" { 11 11 + return "" 12 12 + } 13 13 + 14 14 + if removeTracking { 15 15 + sanitized = RemoveTrackingParameters(sanitized) 16 16 + } 17 17 + 18 18 + if len(redirections) > 0 { 19 19 + sanitized = ApplyRedirections(sanitized, redirections) 20 20 + } 21 21 + 22 22 + return sanitized 23 23 + }

+1 -4

internal/routing/redirection.go

Reviewed

··· 16 16 } 17 17 18 18 func applyRedirection(rawURL string, redirection Redirection) string { 19 19 - redirectionType := redirection.Type 20 20 - if redirectionType == "" { 21 21 - redirectionType = "domain" 22 22 - } 19 19 + redirectionType := NormalizeRedirectionType(redirection.Type) 23 20 24 21 switch redirectionType { 25 22 case "domain":

+12

internal/routing/validation.go

Reviewed

··· 119 119 redirectionType = "domain" 120 120 } 121 121 122 122 + // Reject unknown types before validating the pattern. 123 123 + valid := false 124 124 + for _, def := range redirectionTypes { 125 125 + if def.Type == redirectionType { 126 126 + valid = true 127 127 + break 128 128 + } 129 129 + } 130 130 + if !valid { 131 131 + return fmt.Errorf("Invalid redirection type: %s", redirectionType) 132 132 + } 133 133 + 122 134 switch redirectionType { 123 135 case "domain": 124 136 return validateDomainPattern(redirection.Find)