Source file raw.ml

(*****************************************************************************)
(*                                                                           *)
(*  Copyright (C) 2026 Yves Ndiaye                                           *)
(*                                                                           *)
(* This Source Code Form is subject to the terms of the Mozilla Public       *)
(* License, v. 2.0. If a copy of the MPL was not distributed with this       *)
(* file, You can obtain one at https://mozilla.org/MPL/2.0/.                 *)
(*                                                                           *)
(*****************************************************************************)

module Line = struct
  type t = KeyVal of (string * string) | Section of string

  let lines file =
    let content = In_channel.with_open_bin file SkhcUtil.FileSys.read_chan in
    let lines = content |> String.split_on_char '\n' in
    List.filter_map
      (fun string ->
        let ( let* ) = Option.bind in
        let string = String.trim string in
        let strlen = String.length string in
        let* () = match strlen > 0 with false -> None | true -> Some () in
        let c = string.[0] in
        match c with
        | '#' | ';' ->
            None
        | '.' ->
            let section = String.sub string 1 (strlen - 1) in
            Some (Section section)
        | _ -> (
            match String.split_on_char '=' string with
            | [] ->
                None
            | t :: q ->
                let key = String.trim t in
                let value = String.trim (String.concat "=" q) in
                Some (KeyVal (key, value))
          )
      )
      lines
end

type t = { globals : (string * string) list; sections : Section.t list }

let empty = { globals = []; sections = [] }

let add_current_section current_section key_vals t =
  let globals = List.rev key_vals in
  match current_section with
  | None ->
      { t with globals }
  | Some name ->
      let s = Section.init name globals in
      { t with sections = s :: t.sections }

let rec sections_of_lines t current_section key_vals lines =
  match lines with
  | [] ->
      let t = add_current_section current_section key_vals t in
      { t with sections = List.rev t.sections }
  | line :: lines -> (
      match line with
      | Line.Section section ->
          let t = add_current_section current_section key_vals t in
          sections_of_lines t (Some section) [] lines
      | KeyVal p ->
          sections_of_lines t current_section (p :: key_vals) lines
    )

let sections_of_lines = sections_of_lines empty None []

let of_line file =
  let lines = Line.lines file in
  sections_of_lines lines

let init globals sections = { globals; sections }

let find_section f t =
  List.find_map
    (fun (section : Section.t) ->
      match f (Section.name section) with true -> Some section | false -> None
    )
    t.sections

let filter_section f t =
  List.filter_map
    (fun (section : Section.t) ->
      match f (Section.name section) with true -> Some section | false -> None
    )
    t.sections

let to_channel oc t =
  let { globals; sections } = t in
  let () =
    List.iter
      (fun (key, value) -> Printf.fprintf oc "%s = %s\n" key value)
      globals
  in
  let () = Printf.fprintf oc "\n" in
  List.iter (Section.to_channel oc) sections