25 Boken om Ridgun

Lib:en `path` — POSIX-normalisering (`path clean`) och Skydd mot Path Traversal

25.1. Varför finns lib:en `path`? (Det verkliga problemet och Ridguns filosofi)

”Varför behöver jag en path-lib skriven från grunden i ren Ridgun i stället för att bara länka in ett gammalt C-bibliotek?”

Det är den första fråga varje systemingenjör ställer sig när man möter path. Och svaret sammanfattar hela filosofin bakom ridgun-libs:

Låt oss vara ärliga: att slå ihop sökvägar med base + "/" + fil utan att rensa ..-segment och kontrollera gränser är en öppen inbjudan till en ../../etc/passwd-attack.

Lib:en path implementerar lexikal POSIX-normalisering (path clean), säker sammanslagning (path join), komponentextrahering (dirname, basename, stem, ext, replace ext) och säkerhetspredikatet path is safe subpath (VUL-INJ-001) mot path traversal.

I ett traditionellt ekosystem innebär uppgifter inom domänen PATH ofta att man drar in externa C-beroenden, brottas med råa pekare, ogenomskinliga typkonverteringar, okontrollerade undantag eller oförutsägbara skräpsamlarpauser. I Ridgun löser lib:en path (src/main/ridgun/lib/path.rg) problemet genom fyra kompromisslösa principer:

Deklarera import path (eller import path as alias) överst i filen: varje lib definierar sin module :: path-namnrymd och i --strict-läge anropas flerordsfunktioner alltid med naturliga mellanslag.
Kedja dina datapipelines från vänster till höger med ->: skriv indata steg ett -> steg två -> resultat, använd (+ _ _ +)-sekvensmasker för att packa upp tupler och utelämna _ = vid sekventiella satser (eller kasta med -> ()).
Svansrekursion med TCO (Tail-Call Optimization): alla interna genomlöpningar i path kompileras till inbyggda hårdvaruloopar med $O(1)$ stackutrymme.
Deterministiskt minne (RMM1 / RMM2): varje mellanliggande struktur frigörs i exakt det ögonblick dess sista läsning avslutas, helt utan Garbage Collector.

25.2. Inbyggda artefakter, import och komplett API-katalog för `path`

I ridgun-libs är path en förstklassig lib placerad i src/main/ridgun/lib/path.rg (domän PATH). När du bygger med stable bundle paketeras den i tre inbyggda format:

Artefakt	Sökväg	Syfte
Ridgun-bundle	`target/bundles/path.rglib`	Portabel distribution och direkt import med `import path`
Kompilerat arkiv	`target/path.rgc`	Typkontrollerad mellanartefakt verifierad av `ridgunc`
Delat ELF64-objekt	`target/libpath.so`	Inbyggt dynamiskt bibliotek helt utan C- eller `libc`-beroenden

Varje lib deklarerar sin egen namnrymd med module :: path: skriv bara import path (eller import path as alias) överst och anropa dess funktioner med naturliga mellanslag (min funktion x) och ->-pipelines (x min funktion -> resultat).

25.2.1. Översikt över funktionella familjer i `path`

Signatur / Funktion / Typ	Vad den gör och när den används
`path clean / path join / path join list`	Slår ihop `//`, `.` och `..` lexikalt och förenar sökvägssegment
`path dirname / path basename / path split`	Delar upp en sökväg i föräldrakatalog och sista filnamnskomponent
`path ext / path stem / path replace ext`	Extraherar eller byter filändelse (behandlar `.bashrc` som basnamn `.bashrc`, ändelse `""`)
`path is safe subpath : String -> String -> Bool`	Verifierar att `rel` stannar strikt inom `base_dir` och saknar NUL-bytes

25.2.2. Komplett katalog över typer och signaturer i `src/main/ridgun/lib/path.rg`

Nedan följer hela förteckningen över algebraiska datatyper (type), mixfix-operatorer (op ::) och funktionssignaturer (fn ::) som definieras i src/main/ridgun/lib/path.rg (0 typer, 0 operatorer och 30 funktioner):

#	Funktion / Signatur (`fn ::`)	Returtyp
`1`	`fn :: pa split slash loop String Int Int Int`	`[String]`
`2`	`fn :: pa rev strs [String] [String]`	`[String]`
`3`	`fn :: pa join slash [String]`	`String`
`4`	`fn :: pa pop stack [String] Bool`	`[String]`
`5`	`fn :: pa norm segs [String] [String] Bool`	`[String]`
`6`	`fn :: pa finish clean String Bool`	`String`
`7`	`fn :: path is abs String`	`Bool`
`8`	`fn :: path is rel String`	`Bool`
`9`	`fn :: path clean String`	`String`
`10`	`fn :: path join String String`	`String`
`11`	`fn :: path join list [String]`	`String`
`12`	`fn :: pa last char idx String Int Int`	`Int`
`13`	`fn :: pa dirname at String Int`	`String`
`14`	`fn :: pa dirname clean String`	`String`
`15`	`fn :: path dirname String`	`String`
`16`	`fn :: pa basename at String Int`	`String`
`17`	`fn :: pa basename clean String`	`String`
`18`	`fn :: path basename String`	`String`
`19`	`fn :: path split String`	`String String`
`20`	`fn :: pa ext at String Int`	`String`
`21`	`fn :: path ext String`	`String`
`22`	`fn :: pa stem at String Int`	`String`
`23`	`fn :: path stem String`	`String`
`24`	`fn :: pa norm ext String`	`String`
`25`	`fn :: pa combine dir base String String`	`String`
`26`	`fn :: path replace ext String String`	`String`
`27`	`fn :: pa is safe char Int`	`Bool`
`28`	`fn :: pa safe chars loop String Int Int`	`Bool`
`29`	`fn :: pa check prefix String String`	`Bool`
`30`	`fn :: path is safe subpath String String`	`Bool`

25.3. Djupdykning i `path`: Steg-för-steg-exempel för varje funktion

Det räcker inte med en signaturtabell: låt oss utforska varje funktionalitet i lib:en path genom progressiva, körbara Ridgun-exempel. Vi börjar med två tabellbaserade vardagsrecept och går därefter igenom alla funktionella scenarier, transformationer och gränsfall som verifieras i src/test/ridgun/test path.rg.

25.3.1. Exempel 1: Huvudflöde i tabellform med `path`

Lägg märke till hur =-tecknen och transformationsstegen med path linjeras som en ren tabell utan onödiga muterbara variabler eller dolda sidoeffekter:

import path

fn :: resolver archivo estatico String String => Bool String
      resolver archivo estatico raiz peticion =
        path is safe subpath raiz peticion -> seguro
        path join raiz peticion -> ruta
        (seguro, ruta)

25.3.2. Exempel 2: Säker komposition och hantering av gränsfall

Varje funktion i lib:en path är utformad för att kombineras sömlöst med booleska vakter | och med övriga 32 libs i ridgun-libs:

import path

fn :: cambiar salida a objeto String => String String String
      cambiar salida a objeto fuente =
        fuente path dirname -> dir
        fuente path stem -> nom
        fuente path clean -> limpio
        path with ext limpio ".rglib" -> obj
        (dir, nom, obj)

25.3.3. Exempel 3: Lexikalisk POSIX-normalisering (`path clean`) och säker segmentsammanslagning (`path join`, `path join all`)

I detta praktiska exempel undersöker vi grundligt hur path beter sig inom detta funktionsområde, inklusive standardindata, parameterkombinationer och gränsvärden:

fn :: test path clean and join => ()
      test path clean and join =
        -- Go path/path_test.go cleantests vectors
        assert str eq (path clean "") "." "AC1: empty -> ."
        assert str eq (path clean ".") "." "AC1: . -> ."
        assert str eq (path clean "././.") "." "AC1: ././. -> ."
        assert str eq (path clean "/") "/" "AC1: / -> /"
        assert str eq (path clean "///") "/" "AC1: /// -> /"
        assert str eq (path clean "/././") "/" "AC1: /././ -> /"
        assert str eq (path clean "/../a") "/a" "AC1: /../a clamped at root"
        assert str eq (path clean "/../../..") "/" "AC1: /../../.. clamped at root"
        assert str eq (path clean "a/b/..") "a" "AC1: a/b/.. -> a"
        assert str eq (path clean "a/../b") "b" "AC1: a/../b -> b"
        assert str eq (path clean "a/../../b") "../b" "AC1: relative .. preserved when above ."
        assert str eq (path clean "../../a/b/..") "../../a" "AC1: leading ../.. preserved"
        assert str eq (path clean "/a/b/../c/./d//") "/a/c/d" "AC1: complex absolute normalization"

        -- path join & path join list
        assert str eq (path join "" "") "." "AC1: join empty empty"
        assert str eq (path join "/var/log" "") "/var/log" "AC1: join with empty right"
        assert str eq (path join "" "app.log") "app.log" "AC1: join with empty left"
        assert str eq (path join "/var/log" "app/server.log") "/var/log/app/server.log" "AC1: join relative child"
        assert str eq (path join "/var/log" "/etc/hosts") "/etc/hosts" "AC1: join absolute child overrides base"
        assert str eq (path join list []) "." "AC1: join_list [] -> ."
        assert str eq (path join list ["src", "main", "ridgun", "lib", "path.rg"]) "src/main/ridgun/lib/path.rg" "AC1: join_list 5 segments"
        ()

25.3.4. Exempel 4: Sökvägsuppdelning (`dirname`, `basename`, `ext`, `stem`) och path traversal-inneslutning (`path is safe rel`, `path resolve under`)

I detta praktiska exempel undersöker vi grundligt hur path beter sig inom detta funktionsområde, inklusive standardindata, parameterkombinationer och gränsvärden:

fn :: test path components and confinement => ()
      test path components and confinement =
        p = "/home/boogie/ridgun-libs/src/socket.rg"
        assert true (path is abs p) "AC2: path_is_abs true"
        assert false (path is rel p) "AC2: path_is_rel false"
        assert false (path is abs "") "AC2: empty is not abs"
        assert true (path is rel "src/socket.rg") "AC2: relative path_is_rel"
        assert str eq (path dirname p) "/home/boogie/ridgun-libs/src" "AC2: dirname"
        assert str eq (path basename p) "socket.rg" "AC2: basename"
        sp = path split p
        assert str eq (pair fst sp) "/home/boogie/ridgun-libs/src" "AC2: split dirname"
        assert str eq (pair snd sp) "socket.rg" "AC2: split basename"
        assert str eq (path dirname "/") "/" "AC2: dirname of / is /"
        assert str eq (path basename "/") "/" "AC2: basename of / is /"
        assert str eq (path dirname "/top") "/" "AC2: dirname of /top is /"
        assert str eq (path dirname "barefile.txt") "." "AC2: dirname of bare filename is ."

        -- Multi-dot filenames, dotfiles, and extension replacement
        assert str eq (path stem p) "socket" "AC2: stem"
        assert str eq (path ext p) ".rg" "AC2: ext"
        assert str eq (path stem "archive.tar.gz") "archive.tar" "AC2: multi-dot stem"
        assert str eq (path ext "archive.tar.gz") ".gz" "AC2: multi-dot ext"
        assert str eq (path stem ".gitignore") ".gitignore" "AC2: dotfile stem"
        assert str eq (path ext ".gitignore") "" "AC2: dotfile empty ext"
        assert str eq (path replace ext p "rglib") "/home/boogie/ridgun-libs/src/socket.rglib" "AC2: replace_ext without leading dot"
        assert str eq (path replace ext p ".so") "/home/boogie/ridgun-libs/src/socket.so" "AC2: replace_ext with leading dot"
        assert str eq (path replace ext "main.rg" "") "main" "AC2: replace_ext with empty removes extension"

        -- OWASP Path Traversal & Shell Injection Confinement (VUL-INJ-002)
        assert true (path is safe subpath "/srv/www" "assets/app.js") "AC3: safe child subpath"
        assert true (path is safe subpath "/srv/www" "a/b/../c_1-2.txt") "AC3: safe normalized internal .."
        assert false (path is safe subpath "/srv/www" "") "AC3: empty child rejected"
        assert false (path is safe subpath "" "assets/app.js") "AC3: empty base rejected"
        assert false (path is safe subpath "/srv/www" "../etc/passwd") "AC3: direct .. traversal rejected"
        assert false (path is safe subpath "/srv/www" "a/b/../../../etc/passwd") "AC3: deep .. traversal escaping base rejected"
        assert false (path is safe subpath "/srv/www" "/etc/passwd") "AC3: absolute child path rejected"
        assert false (path is safe subpath "/srv/www" "/srv/www/index.html") "AC3: absolute child matching base still rejected"
        assert false (path is safe subpath "/srv/www" "bad;rm -rf /") "AC3: shell semicolon metachar rejected"
        assert false (path is safe subpath "/srv/www" "bad|cat") "AC3: shell pipe metachar rejected"
        assert false (path is safe subpath "/srv/www" "bad$var") "AC3: shell dollar metachar rejected"
        ()

25.3.5. Exempel 5: Sandlådesäkrad filuppslagare: skydd mot `..`-traversering, nollbyte och extraktion av `dirname`/`basename`/`ext`/`stem`

I detta praktiska exempel undersöker vi grundligt hur path beter sig inom detta funktionsområde, inklusive standardindata, parameterkombinationer och gränsvärden:

import path

fn :: resolver archivo seguro (raiz : String) (peticion : String) => (String, String, String, String)
      resolver archivo seguro raiz peticion =
        ruta_final = path resolve under raiz peticion
        | ruta_final == "" = ("denegado", "", "", "")
        | otherwise        =
          dir  = path dirname ruta_final
          base = path basename ruta_final
          ext  = path ext ruta_final
          stem = path stem ruta_final
          (ruta_final, dir, base, "{stem} ({ext})")

25.4. Under huven: hur `path` är byggd i ren Ridgun (`src/main/ridgun/lib/path.rg`)

En av de största fördelarna med ridgun-libs är att det inte finns några svarta lådor i C. Du kan öppna src/main/ridgun/lib/path.rg och läsa exakt hur varje operation är implementerad med mönstermatchning, | / |.-vaktträd och svansrekursion (TCO). Låt oss titta på nyckeldelarna i den faktiska implementationen:

25.4.1. Intern implementation: Core Implementation Part 1

Se hur path.rg deklarerar explicita fn :: ... => ...-kontrakt först och löser varje fall genom linjerade ekvationer och svansanrop:

module :: path

fn :: pa split slash loop String Int Int Int => [String]
      pa split slash loop p start idx len =
        | idx >= len                = [(str slice p start len)]
        | (str char at p idx) == 47 = [(str slice p start idx)] :: (pa split slash loop p (idx + 1) (idx + 1) len)
        | otherwise                 = pa split slash loop p start (idx + 1) len

fn :: pa rev strs [String] [String] => [String]
      pa rev strs []       acc      =  acc
      pa rev strs (x:rest) acc      =  pa rev strs rest ([x] :: acc)

fn :: pa join slash [String] => String
      pa join slash []       =  ""
      pa join slash (x:[])   =  x
      pa join slash (x:rest) =  x + "/" + (pa join slash rest)

fn :: pa pop stack [String] Bool  => [String]
      pa pop stack []       True  =  []
      pa pop stack []       False =  [".."]
      pa pop stack (top:rs) is_ab =
        | top == ".." = ["..", ".."] :: rs
        | otherwise   = rs

fn :: pa norm segs [String] [String] Bool => [String]
      pa norm segs [] stack _ = pa rev strs stack []
      pa norm segs (s:rest) stack is_ab =
        | (str len s) == 0 or s == "." = pa norm segs rest stack is_ab
        | s == ".."                    = pa norm segs rest (pa pop stack stack is_ab) is_ab
        | otherwise                    = pa norm segs rest ([s] :: stack) is_ab

fn :: pa finish clean String Bool  => String
      pa finish clean joined True  =
        | (str len joined) == 0 = "/"
        | otherwise             = "/" + joined
      pa finish clean joined False =
        | (str len joined) == 0 = "."
        | otherwise             = joined

fn :: path is abs String => Bool
      path is abs p      =
        | (str len p) == 0        = False
        | (str char at p 0) == 47 = True
        | otherwise               = False

fn :: path is rel String => Bool
      path is rel p      =  not (path is abs p)

fn :: path clean String => String
      path clean p      =
        | (str len p) == 0 = "."
        | otherwise =
          p path is abs -> is_ab
          pa split slash loop p 0 0 (str len p) -> segs
          pa norm segs segs [] is_ab -> norm
          norm pa join slash -> pa finish clean is_ab

fn :: path join String String => String
      path join a      b      =
        | (str len a) == 0 = path clean b
        | (str len b) == 0 = path clean a
        | path is abs b    = path clean b
        | otherwise        = path clean (a + "/" + b)

fn :: path join list [String]   => String
      path join list []         =  "."
      path join list (x:[])     =  path clean x
      path join list (x:y:rest) =  path join list ([(path join x y)] :: rest)

fn :: pa last char idx String Int Int => Int
      pa last char idx s ch idx =
        | idx < 0                   = 0 - 1
        | (str char at s idx) == ch = idx
        | otherwise                 = pa last char idx s ch (idx - 1)

fn :: pa dirname at String Int => String
      pa dirname at cp     idx =
        | idx < 0   = "."
        | idx == 0  = "/"
        | otherwise = str slice cp 0 idx

fn :: pa dirname clean String => String
      pa dirname clean cp     =
        | cp == "/" = "/"
        | otherwise = pa dirname at cp (pa last char idx cp 47 ((str len cp) - 1))

fn :: path dirname String => String
      path dirname p      =  pa dirname clean (path clean p)

25.4.2. Intern implementation: Core Implementation Part 2

Se hur path.rg deklarerar explicita fn :: ... => ...-kontrakt först och löser varje fall genom linjerade ekvationer och svansanrop:

fn :: pa basename at String Int => String
      pa basename at cp     idx =
        | idx < 0   = cp
        | otherwise = str slice cp (idx + 1) (str len cp)

fn :: pa basename clean String => String
      pa basename clean cp     =
        | cp == "/" = "/"
        | otherwise = pa basename at cp (pa last char idx cp 47 ((str len cp) - 1))

fn :: path basename String => String
      path basename p      =  pa basename clean (path clean p)

fn :: path split String => String String
      path split p      =  (path dirname p, path basename p)

fn :: pa ext at String Int => String
      pa ext at base   dot =
        | dot <= 0  = ""
        | otherwise = str slice base dot (str len base)

fn :: path ext String => String
      path ext p      =
        base = path basename p
        pa ext at base (pa last char idx base 46 ((str len base) - 1))

fn :: pa stem at String Int => String
      pa stem at base   dot =
        | dot <= 0  = base
        | otherwise = str slice base 0 dot

fn :: path stem String => String
      path stem p      =
        base = path basename p
        pa stem at base (pa last char idx base 46 ((str len base) - 1))

fn :: pa norm ext String => String
      pa norm ext ext    =
        | (str len ext) == 0        = ""
        | (str char at ext 0) == 46 = ext
        | otherwise                 = "." + ext

fn :: pa combine dir base String String => String
      pa combine dir base dir base =
        | dir == "." = base
        | dir == "/" = "/" + base
        | otherwise  = dir + "/" + base

fn :: path replace ext String String  => String
      path replace ext p      new_ext =
        pa combine dir base (path dirname p) ((path stem p) + (pa norm ext new_ext))

fn :: pa is safe char Int => Bool
      pa is safe char c   =
        | c >= 48 and c <= 57                        = True
        | c >= 65 and c <= 90                        = True
        | c >= 97 and c <= 122                       = True
        | c == 47 or c == 46 or c == 95 or c == 45   = True
        | otherwise                                  = False

fn :: pa safe chars loop String Int Int => Bool
      pa safe chars loop s idx len =
        | idx >= len                          = True
        | not (pa is safe char (str char at s idx)) = False
        | otherwise                           = pa safe chars loop s (idx + 1) len

fn :: pa check prefix String String => Bool
      pa check prefix bclean full   =
        | bclean == "/" = path is abs full
        | full == bclean = True
        | otherwise     = str starts with full (bclean + "/")

fn :: path is safe subpath String String => Bool
      path is safe subpath base child =
        | (str len base) == 0 or (str len child) == 0          = False
        | path is abs child                                    = False
        | not (pa safe chars loop base 0 (str len base))       = False
        | not (pa safe chars loop child 0 (str len child))     = False
        | otherwise =
          bclean = path clean base
          full   = path clean (bclean + "/" + child)
          pa check prefix bclean full

25.4.3. Intern implementation: Core Implementation Part 4

Se hur path.rg deklarerar explicita fn :: ... => ...-kontrakt först och löser varje fall genom linjerade ekvationer och svansanrop:

fn :: path ext String => String
      path ext p      =
        base = path basename p
        pa ext at base (pa last char idx base 46 ((str len base) - 1))

fn :: pa stem at String Int => String
      pa stem at base   dot =
        | dot <= 0  = base
        | otherwise = str slice base 0 dot

fn :: path stem String => String
      path stem p      =
        base = path basename p
        pa stem at base (pa last char idx base 46 ((str len base) - 1))

fn :: pa norm ext String => String
      pa norm ext ext    =
        | (str len ext) == 0        = ""
        | (str char at ext 0) == 46 = ext
        | otherwise                 = "." + ext

fn :: pa combine dir base String String => String
      pa combine dir base dir base =
        | dir == "." = base
        | dir == "/" = "/" + base
        | otherwise  = dir + "/" + base

fn :: path replace ext String String  => String
      path replace ext p      new_ext =
        pa combine dir base (path dirname p) ((path stem p) + (pa norm ext new_ext))

fn :: pa is safe char Int => Bool
      pa is safe char c   =
        | c >= 48 and c <= 57                        = True
        | c >= 65 and c <= 90                        = True
        | c >= 97 and c <= 122                       = True
        | c == 47 or c == 46 or c == 95 or c == 45   = True
        | otherwise                                  = False

25.4.4. Intern implementation: Core Implementation Part 5

Se hur path.rg deklarerar explicita fn :: ... => ...-kontrakt först och löser varje fall genom linjerade ekvationer och svansanrop:

fn :: pa safe chars loop String Int Int => Bool
      pa safe chars loop s idx len =
        | idx >= len                          = True
        | not (pa is safe char (str char at s idx)) = False
        | otherwise                           = pa safe chars loop s (idx + 1) len

fn :: pa check prefix String String => Bool
      pa check prefix bclean full   =
        | bclean == "/" = path is abs full
        | full == bclean = True
        | otherwise     = str starts with full (bclean + "/")

fn :: path is safe subpath String String => Bool
      path is safe subpath base child =
        | (str len base) == 0 or (str len child) == 0          = False
        | path is abs child                                    = False
        | not (pa safe chars loop base 0 (str len base))       = False
        | not (pa safe chars loop child 0 (str len child))     = False
        | otherwise =
          bclean = path clean base
          full   = path clean (bclean + "/" + child)
          pa check prefix bclean full

25.5. Algoritmiska garantier, `RMM1`/`RMM2`-minne och de 5 Gyllene Reglerna för `path`

Algoritmisk garanti och säkerhet: path is safe subpath avvisar absoluta sökvägar, NUL-bytes och alla ..-sekvenser som försöker lämna baskatalogen eller nå en syskonkatalog (/srv/www-secret).
$O(1)$ stackkomplexitet med TCO: Alla rekursiva loopar i src/main/ridgun/lib/path.rg ligger i svansposition, så ridgunc kompilerar dem till inbyggda hopp utan stacktillväxt.
Deterministiskt minne (RMM1/RMM2): Noll skräpsamlarpauser; alla temporära strukturer frigörs deterministiskt när räckvidden lämnas.
Kontinuerlig verifiering: Statiskt kontrollerad med stable check och verifierad av den automatiserade testsviten src/test/ridgun/test path.rg.

De 5 Gyllene Reglerna när du programmerar med `path`

Deklarera import path överst i filen och utnyttja att mellanslag och understreck är utbytbara så att koden läses som naturlig prosa.
Linjera dina datapipelines med =: kedja samman path-anrop i namngivna mellansteg och låt stable format linjera kolumnerna.
Utnyttja path:s totala funktioner i dina |-vakter: kontrollera returvärden eller packa upp ADT:er med mönstermatchning i stället för att anta att extern indata alltid är giltig.
Undvik att kopiera stora strukturer när du bara läser ett fält: kom ihåg att i RMM2 medför inargument noll referensräkningskostnad (+0 / -0).
Kombinera path med test (import test): lås alltid fast dina domäninvarianter med assert equals eller assert true.

I Kapitel 26 går vi vidare och utforskar lib:en time på djupet (Lib:en time — UTC-kalender (Hinnant), ISO-8601, Varaktigheter och Backoff).

Lib:en path — POSIX-normalisering (path clean) och Skydd mot Path Traversal

25.1. Varför finns lib:en path? (Det verkliga problemet och Ridguns filosofi)

25.2. Inbyggda artefakter, import och komplett API-katalog för path

25.2.1. Översikt över funktionella familjer i path

25.2.2. Komplett katalog över typer och signaturer i src/main/ridgun/lib/path.rg

25.3. Djupdykning i path: Steg-för-steg-exempel för varje funktion

25.3.1. Exempel 1: Huvudflöde i tabellform med path

25.3.2. Exempel 2: Säker komposition och hantering av gränsfall

25.3.3. Exempel 3: Lexikalisk POSIX-normalisering (path clean) och säker segmentsammanslagning (path join, path join all)

25.3.4. Exempel 4: Sökvägsuppdelning (dirname, basename, ext, stem) och path traversal-inneslutning (path is safe rel, path resolve under)

25.3.5. Exempel 5: Sandlådesäkrad filuppslagare: skydd mot ..-traversering, nollbyte och extraktion av dirname/basename/ext/stem

25.4. Under huven: hur path är byggd i ren Ridgun (src/main/ridgun/lib/path.rg)

25.4.1. Intern implementation: Core Implementation Part 1

25.4.2. Intern implementation: Core Implementation Part 2

25.4.3. Intern implementation: Core Implementation Part 4

25.4.4. Intern implementation: Core Implementation Part 5

25.5. Algoritmiska garantier, RMM1/RMM2-minne och de 5 Gyllene Reglerna för path

De 5 Gyllene Reglerna när du programmerar med path

Lib:en `path` — POSIX-normalisering (`path clean`) och Skydd mot Path Traversal

25.1. Varför finns lib:en `path`? (Det verkliga problemet och Ridguns filosofi)

25.2. Inbyggda artefakter, import och komplett API-katalog för `path`

25.2.1. Översikt över funktionella familjer i `path`

25.2.2. Komplett katalog över typer och signaturer i `src/main/ridgun/lib/path.rg`

25.3. Djupdykning i `path`: Steg-för-steg-exempel för varje funktion

25.3.1. Exempel 1: Huvudflöde i tabellform med `path`

25.3.3. Exempel 3: Lexikalisk POSIX-normalisering (`path clean`) och säker segmentsammanslagning (`path join`, `path join all`)

25.3.4. Exempel 4: Sökvägsuppdelning (`dirname`, `basename`, `ext`, `stem`) och path traversal-inneslutning (`path is safe rel`, `path resolve under`)

25.3.5. Exempel 5: Sandlådesäkrad filuppslagare: skydd mot `..`-traversering, nollbyte och extraktion av `dirname`/`basename`/`ext`/`stem`

25.4. Under huven: hur `path` är byggd i ren Ridgun (`src/main/ridgun/lib/path.rg`)

25.5. Algoritmiska garantier, `RMM1`/`RMM2`-minne och de 5 Gyllene Reglerna för `path`

De 5 Gyllene Reglerna när du programmerar med `path`