Mercurial Hosting > d2o
annotate icf/icf.go @ 12:84384cccda0e
bubfix subpaths and remove hardcode
| author | atarwn@g5 |
|---|---|
| date | Mon, 23 Mar 2026 12:05:05 +0500 |
| parents | 2ffb8028ccbb |
| children | 9460f83a5664 |
| rev | line source |
|---|---|
| 0 | 1 // Package icf implements the Inherited Configuration Format parser. |
| 2 // | |
| 3 // ICF is a rule-based configuration format with variables, abstract blocks | |
| 4 // (mixins), pattern matching with named capture groups, and brace expansion. | |
| 5 package icf | |
| 6 | |
| 7 import ( | |
| 8 "bufio" | |
| 9 "fmt" | |
| 10 "io" | |
| 11 "strings" | |
| 12 ) | |
| 13 | |
| 14 type Directive struct { | |
| 15 Key string | |
| 16 Args []string | |
| 17 } | |
| 18 | |
| 19 type Config struct { | |
|
6
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
20 vars map[string]string |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
21 abstract map[string][]Directive |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
22 abstractMixin map[string]string // mixin name for each abstract block |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
23 Blocks []ParsedBlock |
| 0 | 24 } |
| 25 | |
| 26 type ParsedBlock struct { | |
| 27 ID string | |
| 28 Mixin string | |
| 29 Directives []Directive | |
| 30 } | |
| 31 | |
| 2 | 32 type rawBlock struct { |
| 33 id string | |
| 34 mixin string | |
| 35 directives []rawDirective | |
| 36 } | |
| 37 | |
| 38 type rawDirective struct { | |
| 39 key string | |
| 40 args []string // after brace expansion, before var substitution | |
| 41 } | |
| 42 | |
| 0 | 43 func Parse(r io.Reader) (*Config, error) { |
| 2 | 44 lines, err := readLines(r) |
| 45 if err != nil { | |
| 46 return nil, err | |
| 0 | 47 } |
| 48 | |
| 2 | 49 // --- Pass 1: collect variables --- |
| 50 vars := make(map[string]string) | |
| 4 | 51 subst := makeSubst(vars) |
| 52 | |
| 2 | 53 for _, line := range lines { |
| 54 if i := strings.Index(line, "="); i > 0 && !strings.HasPrefix(line, "|>") { | |
| 55 key := line[:i] | |
| 56 if isVarName(key) { | |
| 4 | 57 vars[key] = subst(strings.TrimSpace(line[i+1:]), nil) |
| 2 | 58 } |
| 59 } | |
| 60 } | |
| 61 | |
| 62 // --- Pass 2: parse blocks (raw, no capture substitution yet) --- | |
| 63 var raws []rawBlock | |
| 64 var cur *rawBlock | |
| 0 | 65 |
| 66 flush := func() { | |
| 67 if cur != nil { | |
| 2 | 68 raws = append(raws, *cur) |
| 0 | 69 cur = nil |
| 70 } | |
| 71 } | |
| 72 | |
| 2 | 73 for _, line := range lines { |
| 0 | 74 if i := strings.Index(line, "="); i > 0 && !strings.HasPrefix(line, "|>") { |
| 2 | 75 if isVarName(line[:i]) { |
| 0 | 76 continue |
| 77 } | |
| 78 } | |
| 79 | |
| 80 if strings.HasPrefix(line, "|>") { | |
| 81 if cur == nil { | |
| 82 return nil, fmt.Errorf("icf: directive outside block: %q", line) | |
| 83 } | |
| 84 parts := strings.Fields(strings.TrimSpace(line[2:])) | |
| 85 if len(parts) == 0 { | |
| 86 continue | |
| 87 } | |
| 2 | 88 cur.directives = append(cur.directives, rawDirective{ |
| 89 key: parts[0], | |
| 90 args: braceExpand(parts[1:]), | |
| 0 | 91 }) |
| 92 continue | |
| 93 } | |
| 94 | |
| 95 flush() | |
| 96 parts := strings.Fields(line) | |
| 2 | 97 rb := rawBlock{id: subst(parts[0], nil)} |
| 0 | 98 if len(parts) >= 2 && strings.HasPrefix(parts[1], "@") { |
| 2 | 99 rb.mixin = subst(parts[1][1:], nil) |
| 0 | 100 } |
| 2 | 101 cur = &rb |
| 0 | 102 } |
| 103 flush() | |
| 104 | |
| 2 | 105 // --- Pass 3: separate abstract from concrete, apply var substitution --- |
| 106 c := &Config{ | |
|
6
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
107 vars: vars, |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
108 abstract: make(map[string][]Directive), |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
109 abstractMixin: make(map[string]string), |
| 0 | 110 } |
| 111 | |
| 2 | 112 for _, rb := range raws { |
| 113 dirs := make([]Directive, len(rb.directives)) | |
| 114 for i, rd := range rb.directives { | |
| 115 args := make([]string, len(rd.args)) | |
| 116 for j, a := range rd.args { | |
| 117 args[j] = subst(a, nil) | |
| 118 } | |
| 119 dirs[i] = Directive{Key: rd.key, Args: args} | |
| 120 } | |
| 121 | |
| 122 if strings.HasPrefix(rb.id, "@") { | |
|
6
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
123 name := rb.id[1:] |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
124 c.abstract[name] = dirs |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
125 if rb.mixin != "" { |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
126 c.abstractMixin[name] = rb.mixin |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
127 } |
| 0 | 128 } else { |
| 2 | 129 c.Blocks = append(c.Blocks, ParsedBlock{ |
| 130 ID: rb.id, | |
| 131 Mixin: rb.mixin, | |
| 132 Directives: dirs, | |
| 133 }) | |
| 0 | 134 } |
| 135 } | |
| 136 | |
| 137 return c, nil | |
| 138 } | |
| 139 | |
| 2 | 140 // Abstract returns the directives of a named abstract block. |
| 141 // Returns nil if not found. | |
| 0 | 142 func (c *Config) Abstract(name string) []Directive { |
| 2 | 143 return c.abstract[name] |
| 0 | 144 } |
| 145 | |
| 146 // Match finds the most specific block matching input (e.g. "host/path") and | |
| 147 // returns resolved directives plus named captures. | |
| 2 | 148 // Domain is matched exactly; path uses prefix match. |
| 12 | 149 func (c *Config) Match(input string) ([]Directive, map[string]string, string) { |
| 0 | 150 inHost, inPath, _ := strings.Cut(input, "/") |
| 151 | |
| 152 type hit struct { | |
| 153 block ParsedBlock | |
| 154 captures map[string]string | |
| 155 score int | |
| 12 | 156 rem string |
| 0 | 157 } |
| 158 var best *hit | |
| 159 | |
| 160 for _, b := range c.Blocks { | |
| 161 patHost, patPath, hasPath := strings.Cut(b.ID, "/") | |
| 162 caps := make(map[string]string) | |
| 163 | |
| 164 domScore, ok := matchExact(patHost, inHost, caps) | |
| 165 if !ok { | |
| 166 continue | |
| 167 } | |
| 168 | |
| 169 pathScore := 0 | |
| 12 | 170 rem := inPath |
| 0 | 171 if hasPath { |
| 12 | 172 var pathRem string |
| 173 pathScore, pathRem, ok = matchPrefix(patPath, inPath, caps) | |
| 0 | 174 if !ok { |
| 175 continue | |
| 176 } | |
| 12 | 177 rem = pathRem |
| 0 | 178 } |
| 179 | |
| 180 score := domScore*1000 + pathScore | |
| 181 if best == nil || score > best.score { | |
| 12 | 182 best = &hit{block: b, captures: caps, score: score, rem: rem} |
| 0 | 183 } |
| 184 } | |
| 185 | |
| 186 if best == nil { | |
| 12 | 187 return nil, nil, "" |
| 0 | 188 } |
| 189 | |
| 12 | 190 // rem is the unmatched suffix after the path pattern. |
| 191 // Ensure it starts with "/" to form a valid absolute subpath. | |
| 192 subPath := best.rem | |
| 193 if !strings.HasPrefix(subPath, "/") { | |
| 194 subPath = "/" + subPath | |
| 195 } | |
| 196 return c.ResolveBlock(best.block, best.captures), best.captures, subPath | |
| 0 | 197 } |
| 198 | |
| 2 | 199 // ResolveBlock merges mixin directives (lower priority) with block directives, |
| 200 // then substitutes capture variables. | |
| 0 | 201 func (c *Config) ResolveBlock(b ParsedBlock, caps map[string]string) []Directive { |
| 202 var merged []Directive | |
| 203 if b.Mixin != "" { | |
|
6
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
204 merged = append(merged, c.resolveAbstract(b.Mixin, make(map[string]bool))...) |
| 0 | 205 } |
| 206 merged = append(merged, b.Directives...) | |
| 2 | 207 |
| 208 if len(caps) == 0 { | |
| 209 return merged | |
| 210 } | |
| 0 | 211 |
| 2 | 212 // Substitute capture variables into a copy |
| 213 subst := makeSubst(c.vars) | |
| 214 out := make([]Directive, len(merged)) | |
| 215 for i, d := range merged { | |
| 216 out[i].Key = d.Key | |
| 0 | 217 out[i].Args = make([]string, len(d.Args)) |
| 218 for j, a := range d.Args { | |
| 2 | 219 out[i].Args[j] = subst(a, caps) |
| 0 | 220 } |
| 221 } | |
| 222 return out | |
| 223 } | |
| 224 | |
|
6
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
225 // resolveAbstract recursively expands an abstract block and its mixin chain. |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
226 // visited guards against circular references. |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
227 func (c *Config) resolveAbstract(name string, visited map[string]bool) []Directive { |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
228 if visited[name] { |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
229 return nil |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
230 } |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
231 visited[name] = true |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
232 |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
233 var out []Directive |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
234 if parent, ok := c.abstractMixin[name]; ok { |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
235 out = append(out, c.resolveAbstract(parent, visited)...) |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
236 } |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
237 out = append(out, c.abstract[name]...) |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
238 return out |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
239 } |
|
54ab94198677
abstract mixins + building sctipt + documentation
Atarwn Gard <a@qwa.su>
parents:
4
diff
changeset
|
240 |
| 2 | 241 // makeSubst returns a function that substitutes $VAR in s, |
| 242 // checking caps first, then vars. | |
| 243 func makeSubst(vars map[string]string) func(s string, caps map[string]string) string { | |
| 244 return func(s string, caps map[string]string) string { | |
| 245 if !strings.Contains(s, "$") { | |
| 246 return s | |
| 0 | 247 } |
| 2 | 248 var b strings.Builder |
| 249 i := 0 | |
| 250 for i < len(s) { | |
| 251 if s[i] != '$' { | |
| 252 b.WriteByte(s[i]) | |
| 253 i++ | |
| 254 continue | |
| 255 } | |
| 256 j := i + 1 | |
| 257 for j < len(s) && isVarChar(s[j]) { | |
| 258 j++ | |
| 259 } | |
| 260 name := s[i+1 : j] | |
| 261 if caps != nil { | |
| 262 if v, ok := caps[name]; ok { | |
| 263 b.WriteString(v) | |
| 264 i = j | |
| 265 continue | |
| 266 } | |
| 267 } | |
| 268 if v, ok := vars[name]; ok { | |
| 269 b.WriteString(v) | |
| 270 } else { | |
| 271 b.WriteString(s[i:j]) | |
| 272 } | |
| 273 i = j | |
| 0 | 274 } |
| 2 | 275 return b.String() |
| 276 } | |
| 277 } | |
| 278 | |
| 279 func readLines(r io.Reader) ([]string, error) { | |
| 280 var out []string | |
| 281 scanner := bufio.NewScanner(r) | |
| 282 for scanner.Scan() { | |
| 283 line := stripComment(strings.TrimSpace(scanner.Text())) | |
| 284 if line != "" { | |
| 285 out = append(out, line) | |
| 0 | 286 } |
| 287 } | |
| 2 | 288 return out, scanner.Err() |
| 0 | 289 } |
| 290 | |
| 291 func matchExact(pat, s string, caps map[string]string) (int, bool) { | |
| 292 score, rem, ok := matchCaptures(pat, s, caps) | |
| 293 if !ok || rem != "" { | |
| 294 return 0, false | |
| 295 } | |
| 296 return score, true | |
| 297 } | |
| 298 | |
| 12 | 299 func matchPrefix(pat, s string, caps map[string]string) (int, string, bool) { |
| 300 score, rem, ok := matchCaptures(pat, s, caps) | |
| 301 return score, rem, ok | |
| 0 | 302 } |
| 303 | |
| 304 func matchCaptures(pat, inp string, caps map[string]string) (int, string, bool) { | |
| 305 for { | |
| 306 if pat == "" { | |
| 307 return 0, inp, true | |
| 308 } | |
| 309 | |
| 310 if strings.HasPrefix(pat, "<") { | |
| 311 end := strings.Index(pat, ">") | |
| 312 if end == -1 { | |
| 313 return 0, "", false | |
| 314 } | |
| 315 capName := pat[1:end] | |
| 316 rest := pat[end+1:] | |
| 317 | |
|
8
2ffb8028ccbb
add loggingmodes and fix path matching
Atarwn Gard <a@qwa.su>
parents:
6
diff
changeset
|
318 for split := len(inp); split >= 1; split-- { |
| 12 | 319 // Captures never span path separators: <n> matches one segment only. |
| 320 if strings.Contains(inp[:split], "/") { | |
| 321 continue | |
| 322 } | |
| 2 | 323 score, finalRem, ok := matchCaptures(rest, inp[split:], caps) |
| 0 | 324 if ok { |
| 325 if capName != "_" { | |
| 2 | 326 caps[capName] = inp[:split] |
| 0 | 327 } |
| 328 return score, finalRem, true | |
| 329 } | |
| 330 } | |
| 331 return 0, "", false | |
| 332 } | |
| 333 | |
| 334 if inp == "" || pat[0] != inp[0] { | |
| 335 return 0, "", false | |
| 336 } | |
| 337 score, rem, ok := matchCaptures(pat[1:], inp[1:], caps) | |
| 338 return score + 1, rem, ok | |
| 339 } | |
| 340 } | |
| 341 | |
| 342 func braceExpand(args []string) []string { | |
| 343 var out []string | |
| 344 for _, a := range args { | |
| 345 out = append(out, expandOne(a)...) | |
| 346 } | |
| 347 return out | |
| 348 } | |
| 349 | |
| 350 func expandOne(s string) []string { | |
| 351 start := strings.Index(s, "{") | |
| 352 end := strings.Index(s, "}") | |
| 353 if start == -1 || end == -1 || end < start { | |
| 354 return []string{s} | |
| 355 } | |
| 356 prefix := s[:start] | |
| 357 suffix := s[end+1:] | |
| 358 var out []string | |
| 359 for _, v := range strings.Split(s[start+1:end], ",") { | |
| 360 out = append(out, prefix+strings.TrimSpace(v)+suffix) | |
| 361 } | |
| 362 return out | |
| 363 } | |
| 364 | |
| 365 func stripComment(line string) string { | |
| 366 if strings.HasPrefix(line, ";") { | |
| 367 return "" | |
| 368 } | |
| 369 if i := strings.Index(line, " ;"); i != -1 { | |
| 370 return strings.TrimSpace(line[:i]) | |
| 371 } | |
| 372 return line | |
| 373 } | |
| 374 | |
| 375 func isVarName(s string) bool { | |
| 376 if s == "" { | |
| 377 return false | |
| 378 } | |
| 379 for i := 0; i < len(s); i++ { | |
| 380 if !isVarChar(s[i]) { | |
| 381 return false | |
| 382 } | |
| 383 } | |
| 384 return true | |
| 385 } | |
| 386 | |
| 387 func isVarChar(c byte) bool { | |
| 388 return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || | |
| 389 (c >= '0' && c <= '9') || c == '_' | |
| 2 | 390 } |