This file is indexed.

/usr/share/augeas/lenses/dist/inifile.aug is in augeas-lenses 1.10.1-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
(*
Module: IniFile
  Generic module to create INI files lenses

Author: Raphael Pinson <raphink@gmail.com>

About: License
  This file is licensed under the LGPL v2+, like the rest of Augeas.

About: TODO
  Things to add in the future
  - Support double quotes in value

About: Lens usage
  This lens is made to provide generic primitives to construct INI File lenses.
  See <Puppet>, <PHP>, <MySQL> or <Dput> for examples of real life lenses using it.

About: Examples
  The <Test_IniFile> file contains various examples and tests.
*)

module IniFile  =


(************************************************************************
 * Group:               USEFUL PRIMITIVES
 *************************************************************************)

(* Group: Internal primitives *)

(*
Variable: eol
  End of line, inherited from <Util.eol>
*)
let eol = Util.doseol


(* Group: Separators *)



(*
Variable: sep
  Generic separator

  Parameters:
    pat:regexp - the pattern to delete
    default:string - the default string to use
*)
let sep (pat:regexp) (default:string)
                       = Sep.opt_space . del pat default

(*
Variable: sep_noindent
  Generic separator, no indentation

  Parameters:
    pat:regexp - the pattern to delete
    default:string - the default string to use
*)
let sep_noindent (pat:regexp) (default:string)
                       = del pat default

(*
Variable: sep_re
  The default regexp for a separator
*)

let sep_re             = /[=:]/

(*
Variable: sep_default
  The default separator value
*)
let sep_default        = "="


(* Group: Stores *)


(*
Variable: sto_to_eol
  Store until end of line
*)
let sto_to_eol         = Sep.opt_space . store Rx.space_in

(*
Variable: to_comment_re
  Regex until comment
*)
let to_comment_re = /[^";# \t\n][^";#\n]*[^";# \t\n]|[^";# \t\n]/

(*
Variable: sto_to_comment
  Store until comment
*)
let sto_to_comment = Sep.opt_space . store to_comment_re

(*
Variable: sto_multiline
  Store multiline values
*)
let sto_multiline = Sep.opt_space
         . store (to_comment_re
               . (/[ \t]*\n/ . Rx.space . to_comment_re)*)

(*
Variable: sto_multiline_nocomment
  Store multiline values without an end-of-line comment
*)
let sto_multiline_nocomment = Sep.opt_space
         . store (Rx.space_in . (/[ \t]*\n/ . Rx.space . Rx.space_in)*)


(* Group: Define comment and defaults *)

(*
View: comment_noindent
  Map comments into "#comment" nodes,
  no indentation allowed

  Parameters:
    pat:regexp - pattern to delete before commented data
    default:string - default pattern before commented data

  Sample Usage:
  (start code)
    let comment  = IniFile.comment_noindent "#" "#"
    let comment  = IniFile.comment_noindent IniFile.comment_re IniFile.comment_default
  (end code)
*)
let comment_noindent (pat:regexp) (default:string) =
  Util.comment_generic_seteol (pat . Rx.opt_space) default eol

(*
View: comment
  Map comments into "#comment" nodes

  Parameters:
    pat:regexp - pattern to delete before commented data
    default:string - default pattern before commented data

  Sample Usage:
  (start code)
    let comment  = IniFile.comment "#" "#"
    let comment  = IniFile.comment IniFile.comment_re IniFile.comment_default
  (end code)
*)
let comment (pat:regexp) (default:string) =
  Util.comment_generic_seteol (Rx.opt_space . pat . Rx.opt_space) default eol

(*
Variable: comment_re
  Default regexp for <comment> pattern
*)

let comment_re         = /[;#]/

(*
Variable: comment_default
  Default value for <comment> pattern
*)
let comment_default    = ";"

(*
View: empty_generic
  Empty line, including empty comments

  Parameters:
    indent:regexp     - the indentation regexp
    comment_re:regexp - the comment separator regexp
*)
let empty_generic (indent:regexp) (comment_re:regexp) =
  Util.empty_generic_dos (indent . comment_re? . Rx.opt_space)

(*
View: empty
  Empty line
*)
let empty = empty_generic Rx.opt_space comment_re

(*
View: empty_noindent
  Empty line, without indentation
*)
let empty_noindent = empty_generic "" comment_re


(************************************************************************
 * Group:                     ENTRY
 *************************************************************************)

(* Group: entry includes comments *)

(*
View: entry_generic_nocomment
  A very generic INI File entry, not including comments
  It allows to set the key lens (to set indentation
  or subnodes linked to the key) as well as the comment
  separator regexp, used to tune the store regexps.

  Parameters:
    kw:lens           - lens to match the key, including optional indentation
    sep:lens          - lens to use as key/value separator
    comment_re:regexp - comment separator regexp
    comment:lens      - lens to use as comment

  Sample Usage:
     > let entry = IniFile.entry_generic (key "setting") sep IniFile.comment_re comment
*)
let entry_generic_nocomment (kw:lens) (sep:lens)
                            (comment_re:regexp) (comment:lens) =
     let bare_re_noquot = (/[^" \t\r\n]/ - comment_re)
  in let bare_re = (/[^\r\n]/ - comment_re)+
  in let no_quot = /[^"\r\n]*/
  in let bare = Quote.do_dquote_opt_nil (store (bare_re_noquot . (bare_re* . bare_re_noquot)?))
  in let quoted = Quote.do_dquote (store (no_quot . comment_re+ . no_quot))
  in [ kw . sep . (Sep.opt_space . bare)? . (comment|eol) ]
   | [ kw . sep . Sep.opt_space . quoted . (comment|eol) ]

(*
View: entry_generic
  A very generic INI File entry
  It allows to set the key lens (to set indentation
  or subnodes linked to the key) as well as the comment
  separator regexp, used to tune the store regexps.

  Parameters:
    kw:lens           - lens to match the key, including optional indentation
    sep:lens          - lens to use as key/value separator
    comment_re:regexp - comment separator regexp
    comment:lens      - lens to use as comment

  Sample Usage:
     > let entry = IniFile.entry_generic (key "setting") sep IniFile.comment_re comment
*)
let entry_generic (kw:lens) (sep:lens) (comment_re:regexp) (comment:lens) =
  entry_generic_nocomment kw sep comment_re comment | comment

(*
View: entry
  Generic INI File entry

  Parameters:
    kw:regexp    - keyword regexp for the label
    sep:lens     - lens to use as key/value separator
    comment:lens - lens to use as comment

  Sample Usage:
     > let entry = IniFile.entry setting sep comment
*)
let entry (kw:regexp) (sep:lens) (comment:lens) =
     entry_generic (key kw) sep comment_re comment

(*
View: indented_entry
  Generic INI File entry that might be indented with an arbitrary
  amount of whitespace

  Parameters:
    kw:regexp    - keyword regexp for the label
    sep:lens     - lens to use as key/value separator
    comment:lens - lens to use as comment

  Sample Usage:
     > let entry = IniFile.indented_entry setting sep comment
*)
let indented_entry (kw:regexp) (sep:lens) (comment:lens) =
     entry_generic (Util.indent . key kw) sep comment_re comment

(*
View: entry_multiline_generic
  A very generic multiline INI File entry
  It allows to set the key lens (to set indentation
  or subnodes linked to the key) as well as the comment
  separator regexp, used to tune the store regexps.

  Parameters:
    kw:lens           - lens to match the key, including optional indentation
    sep:lens          - lens to use as key/value separator
    comment_re:regexp - comment separator regexp
    comment:lens      - lens to use as comment
    eol:lens          - lens for end of line

  Sample Usage:
     > let entry = IniFile.entry_generic (key "setting") sep IniFile.comment_re comment comment_or_eol
*)
let entry_multiline_generic (kw:lens) (sep:lens) (comment_re:regexp)
                            (comment:lens) (eol:lens) =
     let newline = /\r?\n[ \t]+/
  in let bare =
          let word_re_noquot = (/[^" \t\r\n]/ - comment_re)+
       in let word_re = (/[^\r\n]/ - comment_re)+
       in let base_re = (word_re_noquot . (word_re* . word_re_noquot)?)
       in let sto_re = base_re . (newline . base_re)*
                     | (newline . base_re)+
       in Quote.do_dquote_opt_nil (store sto_re)
  in let quoted =
          let no_quot = /[^"\r\n]*/
       in let base_re = (no_quot . comment_re+ . no_quot)
       in let sto_re = base_re . (newline . base_re)*
                     | (newline . base_re)+
       in Quote.do_dquote (store sto_re)
  in [ kw . sep . (Sep.opt_space . bare)? . eol ]
   | [ kw . sep . Sep.opt_space . quoted . eol ]
   | comment
  

(*
View: entry_multiline
  Generic multiline INI File entry

  Parameters:
    kw:regexp    - keyword regexp for the label
    sep:lens     - lens to use as key/value separator
    comment:lens - lens to use as comment
*)
let entry_multiline (kw:regexp) (sep:lens) (comment:lens) =
  entry_multiline_generic (key kw) sep comment_re comment (comment|eol)

(*
View: entry_multiline_nocomment
  Generic multiline INI File entry without an end-of-line comment

  Parameters:
    kw:regexp    - keyword regexp for the label
    sep:lens     - lens to use as key/value separator
    comment:lens - lens to use as comment
*)
let entry_multiline_nocomment (kw:regexp) (sep:lens) (comment:lens) =
  entry_multiline_generic (key kw) sep comment_re comment eol

(*
View: entry_list
  Generic INI File list entry

  Parameters:
    kw:regexp     - keyword regexp for the label
    sep:lens      - lens to use as key/value separator
    sto:regexp    - store regexp for the values
    list_sep:lens - lens to use as list separator
    comment:lens  - lens to use as comment
*)
let entry_list (kw:regexp) (sep:lens) (sto:regexp) (list_sep:lens) (comment:lens) =
  let list = counter "elem"
      . Build.opt_list [ seq "elem" . store sto ] list_sep
  in Build.key_value_line_comment kw sep (Sep.opt_space . list) comment

(*
View: entry_list_nocomment
  Generic INI File list entry without an end-of-line comment

  Parameters:
    kw:regexp     - keyword regexp for the label
    sep:lens      - lens to use as key/value separator
    sto:regexp    - store regexp for the values
    list_sep:lens - lens to use as list separator
*)
let entry_list_nocomment (kw:regexp) (sep:lens) (sto:regexp) (list_sep:lens) =
  let list = counter "elem"
      . Build.opt_list [ seq "elem" . store sto ] list_sep
  in Build.key_value_line kw sep (Sep.opt_space . list)

(*
Variable: entry_re
  Default regexp for <entry> keyword
*)
let entry_re           = ( /[A-Za-z][A-Za-z0-9._-]*/ )


(************************************************************************
 * Group:                      RECORD
 *************************************************************************)

(* Group: Title definition *)

(*
View: title
  Title for <record>. This maps the title of a record as a node in the abstract tree.

  Parameters:
    kw:regexp - keyword regexp for the label

  Sample Usage:
    > let title   = IniFile.title IniFile.record_re
*)
let title (kw:regexp)
                       = Util.del_str "[" . key kw
                         . Util.del_str "]". eol

(*
View: indented_title
  Title for <record>. This maps the title of a record as a node in the abstract tree. The title may be indented with arbitrary amounts of whitespace

  Parameters:
    kw:regexp - keyword regexp for the label

  Sample Usage:
    > let title   = IniFile.title IniFile.record_re
*)
let indented_title (kw:regexp)
                       = Util.indent . title kw

(*
View: title_label
  Title for <record>. This maps the title of a record as a value in the abstract tree.

  Parameters:
    name:string - name for the title label
    kw:regexp   - keyword regexp for the label

  Sample Usage:
    > let title   = IniFile.title_label "target" IniFile.record_label_re
*)
let title_label (name:string) (kw:regexp)
                       = label name
                         . Util.del_str "[" . store kw
                         . Util.del_str "]". eol

(*
View: indented_title_label
  Title for <record>. This maps the title of a record as a value in the abstract tree. The title may be indented with arbitrary amounts of whitespace

  Parameters:
    name:string - name for the title label
    kw:regexp   - keyword regexp for the label

  Sample Usage:
    > let title   = IniFile.title_label "target" IniFile.record_label_re
*)
let indented_title_label (name:string) (kw:regexp)
                       = Util.indent . title_label name kw


(*
Variable: record_re
  Default regexp for <title> keyword pattern
*)
let record_re          = ( /[^]\r\n\/]+/ - /#comment/ )

(*
Variable: record_label_re
  Default regexp for <title_label> keyword pattern
*)
let record_label_re    = /[^]\r\n]+/


(* Group: Record definition *)

(*
View: record_noempty
  INI File Record with no empty lines allowed.

  Parameters:
    title:lens - lens to use for title. Use either <title> or <title_label>.
    entry:lens - lens to use for entries in the record. See <entry>.
*)
let record_noempty (title:lens) (entry:lens)
                       = [ title
		       . entry* ]

(*
View: record
  Generic INI File record

  Parameters:
    title:lens - lens to use for title. Use either <title> or <title_label>.
    entry:lens - lens to use for entries in the record. See <entry>.

  Sample Usage:
    > let record  = IniFile.record title entry
*)
let record (title:lens) (entry:lens)
                       = record_noempty title ( entry | empty )


(************************************************************************
 * Group:                      GENERIC LENSES
 *************************************************************************)


(*

Group: Lens definition

View: lns_noempty
  Generic INI File lens with no empty lines

  Parameters:
    record:lens  - record lens to use. See <record_noempty>.
    comment:lens - comment lens to use. See <comment>.

  Sample Usage:
    > let lns     = IniFile.lns_noempty record comment
*)
let lns_noempty (record:lens) (comment:lens)
                       = comment* . record*

(*
View: lns
  Generic INI File lens

  Parameters:
    record:lens  - record lens to use. See <record>.
    comment:lens - comment lens to use. See <comment>.

  Sample Usage:
    > let lns     = IniFile.lns record comment
*)
let lns (record:lens) (comment:lens)
                       = lns_noempty record (comment|empty)


(************************************************************************
 * Group:                   READY-TO-USE LENSES
 *************************************************************************)

let record_anon (entry:lens) = [ label "section" . value ".anon" . ( entry | empty )+ ]

(*
View: lns_loose
  A loose, ready-to-use lens, featuring:
    - sections as values (to allow '/' in names)
    - support empty lines and comments
    - support for [#;] as comment, defaulting to ";"
    - .anon sections
    - don't allow multiline values
    - allow indented titles
    - allow indented entries
*)
let lns_loose = 
     let l_comment = comment comment_re comment_default
  in let l_sep = sep sep_re sep_default
  in let l_entry = indented_entry entry_re l_sep l_comment
  in let l_title = indented_title_label "section" (record_label_re - ".anon")
  in let l_record = record l_title l_entry
  in (record_anon l_entry)? . l_record*

(*
View: lns_loose_multiline
  A loose, ready-to-use lens, featuring:
    - sections as values (to allow '/' in names)
    - support empty lines and comments
    - support for [#;] as comment, defaulting to ";"
    - .anon sections
    - allow multiline values
*)
let lns_loose_multiline = 
     let l_comment = comment comment_re comment_default
  in let l_sep = sep sep_re sep_default
  in let l_entry = entry_multiline entry_re l_sep l_comment
  in let l_title = title_label "section" (record_label_re - ".anon")
  in let l_record = record l_title l_entry
  in (record_anon l_entry)? . l_record*