Source file raw.ml

(**********************************************************************************************)
(*                                                                                            *)
(* This file is part of shakuhachi: a music collection manager                                *)
(* Copyright (C) 2025 Yves Ndiaye                                                             *)
(*                                                                                            *)
(* shakuhachi is free software: you can redistribute it and/or modify it under the terms      *)
(* of the GNU General Public License as published by the Free Software Foundation,            *)
(* either version 3 of the License, or (at your option) any later version.                    *)
(*                                                                                            *)
(* shakuhachi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;    *)
(* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR           *)
(* PURPOSE.  See the GNU General Public License for more details.                             *)
(* You should have received a copy of the GNU General Public License along with shakuhachi.   *)
(* If not, see <http://www.gnu.org/licenses/>.                                                *)
(*                                                                                            *)
(**********************************************************************************************)

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

  let lines file =
    let content = In_channel.with_open_bin file Util.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