catala/build_system/ninja_utils.mli

(* This file is part of the Catala build system, a specification language for
   tax and social benefits computation rules. Copyright (C) 2020 Inria,
   contributor: Emile Rolley <emile.rolley@tuta.io>

   Licensed under the Apache License, Version 2.0 (the "License"); you may not
   use this file except in compliance with the License. You may obtain a copy of
   the License at

   http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   License for the specific language governing permissions and limitations under
   the License. *)

(** {2 What (** This library contains the implementations of utility functions
    used to generate {{:https://ninja-build.org} Ninja} build files in OCaml
    with almost no dependencies -- it only depends on
    {{:https://v3.ocaml.org/p/re/1.10.3/doc/Re/index.html} Re}. It's currently
    developed to be used by
    {{:https://github.com/CatalaLang/catala/tree/master/build_system} Clerk},
    the {{:https://catala-lang.org} Catala} build system. Therefore, the library
    {b supports only very basic features} required by Clerk. *) is Ninja?} *)

(** {{:https://ninja-build.org} Ninja} is a low-level build system. It's
    designed to have its input files ({i build.ninja}) generated by a
    higher-level build system, and to run builds as fast as possible by
    supporting native cross-platform (Windows and Unix) parallel builds.

    See the {{:https://ninja-build.org/manual.html} manual} for more details. *)

(** {1 Ninja expressions} *)

(** Helper module to build ninja expressions. *)
module Expr : sig
  (** Represents a ninja expression. Which could be either a literal, a
      {{:https://ninja-build.org/manual.html#_variables} variable references}
      ($_) or a sequence of sub-expressions.

      {b Note:} for now, there are no visible differences between an [Expr.Seq]
      and a list of {!type: Expr.t}, indeed, in both cases, one space is added
      between each expression -- resp. sub-expression. The difference only comes
      from the semantic: an [Expr.Seq] is {b a unique} Ninja expression. *)
  type t =
    | Lit of string
    (* Literal string. *)
    | Var of string
    (* Variable reference. *)
    | Seq of t list
  (* Sequence of sub-expressions. *)

  val format : Format.formatter -> t -> unit
  (** [format fmt exp] outputs in [fmt] the string representation of the ninja
      expression [exp]. *)

  val format_list : Format.formatter -> t list -> unit
  (** [format fmt ls] outputs in [fmt] the string representation of a list [ls]
      of ninja expressions [exp] by adding a space between each expression. *)
end

(** {1 Ninja rules} *)

(** Helper module to build {{:https://ninja-build.org/manual.html#_rules} ninja
    rules}. *)
module Rule : sig
  type t = { name : string; command : Expr.t; description : Expr.t option }
  (** Represents the minimal ninja rule representation for Clerk:

      {[
        rule <name>
          command = <command>
          [description = <description>]
      ]} *)

  val make : string -> command:Expr.t -> description:Expr.t -> t
  (** [make name ~command ~description] returns the corresponding ninja {!type:
      Rule.t}. *)

  val format : Format.formatter -> t -> unit
  (** [format fmt rule] outputs in [fmt] the string representation of the ninja
      [rule]. *)
end

(** {1 Ninja builds} *)

(** Helper module to build ninja
    {{:https://ninja-build.org/manual.html#_build_statements} build statements}. *)
module Build : sig
  type t = {
    outputs : Expr.t list;
    rule : string;
    inputs : Expr.t list option;
    vars : (string * Expr.t) list;
  }
  (** Represents the minimal ninja build statement representation for Clerk:

      {[
        build <outputs>: <rule> [<inputs>]
          [<vars>]
      ]}*)

  val make : outputs:Expr.t list -> rule:string -> t
  (** [make ~outputs ~rule] returns the corresponding ninja {!type: Build.t}
      with no {!field: inputs} or {!field: vars}. *)

  val make_with_vars :
    outputs:Expr.t list -> rule:string -> vars:(string * Expr.t) list -> t
  (** [make_with_vars ~outputs ~rule ~vars] returns the corresponding ninja
      {!type: Build.t} with no {!field: inputs}. *)

  val make_with_inputs :
    outputs:Expr.t list -> rule:string -> inputs:Expr.t list -> t
  (** [make_with_vars ~outputs ~rule ~inputs] returns the corresponding ninja
      {!type: Build.t} with no {!field: vars}. *)

  val make_with_vars_and_inputs :
    outputs:Expr.t list ->
    rule:string ->
    inputs:Expr.t list ->
    vars:(string * Expr.t) list ->
    t
  (** [make_with_vars ~outputs ~rule ~inputs ~vars] returns the corresponding
      ninja {!type: Build.t}. *)

  val empty : t
  (** [empty] is the minimal ninja {!type: Build.t} with ["empty"] as {!field:
      outputs} and ["phony"] as {!field: rule}. *)

  val unpath : ?sep:string -> string -> string
  (** [unpath ~sep path] replaces all [/] occurences with [sep] in [path] to
      avoid ninja writing the corresponding file and use it as sub command. By
      default, [sep] is set to ["-"]. *)

  val format : Format.formatter -> t -> unit
  (** [format fmt build] outputs in [fmt] the string representation of the ninja
      [build]. *)
end

(** {1 Maps} *)

module RuleMap : Map.S with type key = String.t
module BuildMap : Map.S with type key = String.t

(** {1 Ninja} *)

type ninja = { rules : Rule.t RuleMap.t; builds : Build.t BuildMap.t }
(** Represents the minimal ninja architecture (list of rule and build
    statements) needed for clerk. *)

val empty : ninja
(** [empty] returns the empty empty ninja structure. *)

val format : Format.formatter -> ninja -> unit
(** [format fmt build] outputs in [fmt] the string representation of all
    [ninja.rules] and [ninja.builds]. *)