package opam-format

You can search for identifiers within the package.

in-package search v0.2.0

Format library for opam 2.4

Install

dune-project

Dependency

opam.ocaml.org Readme Edit opam file Versions (30)

Authors

Maintainers

O

opam-devel@lists.ocaml.org

Sources

md5=4eadb5cd5773cff17b19da3c3b70387d

sha512=ee1656715f7e03c36ed9aa0a158033bbdb977d3e9017efa0ceddcd7b073e9b587eb6340ddf1916d9da197c7f48766e569221e6d8e43314bf761326329e4be0a6

doc/opam-format/OpamFilter/index.html

Module `OpamFilter`Source

Formulas on variables, as used in opam files build scripts

Filters are a small language of formulas over strings and booleans used for conditions and text replacements. It has relational operators over strings (using version-number comparison), And, Or and Not boolean operations, dynamic casting (using strings "true" and "false"), and string interpolation. Variables are resolved using a user function returning an option, undefined values are propagated.

String interpolation uses the syntax %{identifier}%

Identifiers have the form

[package:]var[?str_if_true:str_if_false_or_undef]

The last optional part specifies a conversion from boolean to static strings.

The syntax pkg1+pkg2+pkgn:var is allowed as a shortcut to pkg1:var & pkg2:var & pkgn:var.

The special variable pkg:enable is allowed as a shortcut for pkg:installed?enable:disable

val to_string : 
  ?custom:
    (context:[> `And | `Defined | `Not | `Or | `Relop ] ->
      paren:(?cond:bool -> string -> string) ->
      OpamTypes.filter ->
      string option) ->
  OpamTypes.filter ->
  string

Pretty-print custom ?context ?paren filter is a function that permit to customise part of filter pretty-printing.

val fold_down_left : 
  ('a -> OpamTypes.filter -> 'a) ->
  'a ->
  OpamTypes.filter ->
  'a

Folds on the tree of a filter

val map_up : 
  (OpamTypes.filter -> OpamTypes.filter) ->
  OpamTypes.filter ->
  OpamTypes.filter

Maps on all nodes of a filter, bottom-up

Sourceval string_interp_regex : Re.re

Regex matching string interpolation syntax ("%%", "%{xxx}%", or "%{xxx" if unclosed)

Sourceval extract_variables_from_string : string -> string list

Sourceval variables : OpamTypes.filter -> OpamTypes.full_variable list

Returns all the variables appearing in a filter (including the ones within string interpolations

Sourcetype env = OpamTypes.full_variable -> OpamTypes.variable_contents option

Type of filter environment.

type fident =
  OpamTypes.name option list * OpamTypes.variable * (string * string) option

The type of filter idents with (optionally multiple) qualifying package names and optional string converter. Package name None encodes the self-reference _

val map_variables : 
  (OpamTypes.full_variable -> OpamTypes.full_variable) ->
  OpamTypes.filter ->
  OpamTypes.filter

Maps on all variables appearing in a filter.

raises Invalid_argument
when package variables are renamed differently and appear in a filter ident of the form %{pkg1+pkg2:var}%

val map_variables_in_string : 
  (OpamTypes.full_variable -> OpamTypes.full_variable) ->
  string ->
  string

Same limitation as map_variables

val map_variables_in_fident : 
  (OpamTypes.full_variable -> OpamTypes.full_variable) ->
  fident ->
  fident

raises Invalid_argument
when rewriting the variables to different names (which can't be expressed with a fident anymore)

Sourceval distribute_negations : ?neg:bool -> OpamTypes.filter -> OpamTypes.filter

Distributes the negations to apply only to atoms

val expand_string : 
  ?partial:bool ->
  ?default:(string -> string) ->
  env ->
  string ->
  string

Rewrites string interpolations within a string. default is applied to the fident string (e.g. what's between %{ and }%) when the expansion is undefined.

With partial, default defaults to the identity, and is otherwise expected to return a fident. In this case, the returned string is supposed to be expanded again (expansion results are escaped, escapes are otherwise kept). This makes the function idempotent.

raises Failure
if default is unspecified

Sourceval unclosed_expansions : string -> ((int * int) * string) list

Returns the (beginning, end) offsets and substrings of any unclosed %{ expansions

val eval : 
  ?default:OpamTypes.variable_contents ->
  env ->
  OpamTypes.filter ->
  OpamTypes.variable_contents

Computes the value of a filter.

raises Failure
if default isn't provided

Sourceval eval_to_bool : ?default:bool -> env -> OpamTypes.filter -> bool

Like eval but casts the result to a bool.

raises Invalid_argument
if not a valid bool and no default supplied

Sourceval opt_eval_to_bool : env -> OpamTypes.filter option -> bool

Same as eval_to_bool, but takes an option as filter and returns always true on None, false when the filter is Undefined. This is the most common behaviour for using "filters" for filtering

Sourceval eval_to_string : ?default:string -> env -> OpamTypes.filter -> string

Like eval but casts the result to a string

Sourceval partial_eval : env -> OpamTypes.filter -> OpamTypes.filter

Reduces what can be, keeps the rest unchanged

Sourceval ident_of_var : OpamTypes.full_variable -> fident

Wraps a full_variable into a fident accessor

Sourceval ident_of_string : string -> fident

A fident accessor directly referring a variable with the given name

val ident_value : 
  ?default:OpamTypes.variable_contents ->
  env ->
  fident ->
  OpamTypes.variable_contents

Resolves a filter ident.

raises Failure
if no default is provided, like eval

Sourceval ident_string : ?default:string -> env -> fident -> string

Like ident_value, but casts the result to a string

Sourceval ident_bool : ?default:bool -> env -> fident -> bool

Like ident_value, but casts the result to a bool

val expand_interpolations_in_file_full : 
  env ->
  src:OpamTypes.filename ->
  dst:OpamTypes.filename ->
  unit

Same as expand_interpolations_in_file but allows to set the source src and destination dst files independently instead of implying src = dst.in

Sourceval expand_interpolations_in_file : env -> OpamTypes.basename -> unit

Rewrites basename.in to basename, expanding interpolations. If the first line begins "opam-version:", assumes that expansion of variables within strings should be properly escaped. In particular, this means that Windows paths should expand correctly when generating .config files.

Sourceval commands : env -> OpamTypes.command list -> string list list

Processes filters evaluation in a command list: parameter expansion and conditional filtering

Sourceval single_command : env -> OpamTypes.arg list -> string list

Process a simpler command, without filters

Sourceval simple_arg_variables : OpamTypes.simple_arg -> OpamTypes.full_variable list

Extracts the list of variables from an argument

Sourceval commands_variables : OpamTypes.command list -> OpamTypes.full_variable list

Extracts variables appearing in a list of commands

val of_formula : 
  ('a -> OpamTypes.filter) ->
  'a OpamTypes.generic_formula ->
  OpamTypes.filter

Converts a generic formula to a filter, given a converter for atoms

val filter_formula : 
  ?default_version:OpamTypes.version ->
  ?default:bool ->
  env ->
  OpamTypes.filtered_formula ->
  OpamTypes.formula

Resolves the filter in a filtered formula, reducing to a pure formula.

default is the assumed result for undefined filters. If a version filter doesn't resolve to a valid version, the constraint is dropped unless default_version is specified.

raises Invalid_argument
as other filter functions, if default is not provided and filters don't resolve

val partial_filter_formula : 
  env ->
  OpamTypes.filtered_formula ->
  OpamTypes.filtered_formula

Reduces according to what is defined in env, and returns the simplified formula

val gen_filter_formula : 
  ('a -> [< `True | `False | `Formula of 'b OpamTypes.generic_formula ]) ->
  ('c * 'a) OpamFormula.formula ->
  ('c * 'b OpamTypes.generic_formula) OpamFormula.formula

A more generic formula reduction function, that takes a "partial resolver" as argument

Sourceval string_of_filtered_formula : OpamTypes.filtered_formula -> string

val variables_of_filtered_formula : 
  OpamTypes.filtered_formula ->
  OpamTypes.full_variable list

val filter_deps : 
  build:bool ->
  post:bool ->
  ?test:bool ->
  ?doc:bool ->
  ?dev_setup:bool ->
  ?dev:bool ->
  ?default_version:OpamTypes.version ->
  ?default:bool ->
  OpamTypes.filtered_formula ->
  OpamTypes.formula

Resolves the build, post, test, doc, dev flags in a filtered formula (which is supposed to have been pre-processed to remove switch and global variables). default determines the behaviour on undefined filters, and the function may raise if it is undefined. If a constraint resolves to an invalid version, it is dropped, or replaced with default_version if specified. If test, doc or dev are unspecified, they are assumed to be filtered out already and encountering them will raise an assert.

val deps_var_env : 
  build:bool ->
  post:bool ->
  ?test:bool ->
  ?doc:bool ->
  ?dev_setup:bool ->
  ?dev:bool ->
  env

The environment used in resolving the dependency filters, as per filter_deps.

val simplify_extended_version_formula : 
  OpamTypes.condition ->
  OpamTypes.condition option

Like OpamFormula.simplify_version_formula, but on filtered formulas (filters are kept unchanged, but put in front)

val atomise_extended : 
  OpamTypes.filtered_formula ->
  (OpamPackage.Name.t
   * (OpamTypes.filter * (OpamTypes.relop * OpamTypes.filter) option))
    OpamFormula.formula

val sort_filtered_formula : 
  ((OpamTypes.name * OpamTypes.condition) ->
    (OpamTypes.name * OpamTypes.condition) ->
    int) ->
  OpamTypes.filtered_formula ->
  OpamTypes.filtered_formula