augeas-lenses 1.2.0-0ubuntu1 / usr / share / augeas / lenses / dist / build.aug

This file is indexed.

/usr/share/augeas/lenses/dist/build.aug is in augeas-lenses 1.2.0-0ubuntu1.

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
(*
Module: Build
   Generic functions to build lenses

Author: Raphael Pinson <raphink@gmail.com>

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

About: Reference
  This file provides generic functions to build Augeas lenses
*)


module Build =

let eol = Util.eol

(************************************************************************
 * Group:               GENERIC CONSTRUCTIONS
 ************************************************************************)

(************************************************************************
 * View: brackets
 *   Put a lens inside brackets
 *
 *   Parameters:
 *     l:lens   - the left bracket lens
 *     r: lens  - the right bracket lens
 *     lns:lens - the lens to put inside brackets
 ************************************************************************)
let brackets (l:lens) (r:lens) (lns:lens) = l . lns . r


(************************************************************************
 * Group:             LIST CONSTRUCTIONS
 ************************************************************************)

(************************************************************************
 * View: list
 *   Build a list of identical lenses separated with a given separator
 *   (at least 2 elements)
 *
 *   Parameters:
 *     lns:lens - the lens to repeat in the list
 *     sep:lens - the separator lens, which can be taken from the <Sep> module
 ************************************************************************)
let list (lns:lens) (sep:lens) = lns . ( sep . lns )+


(************************************************************************
 * View: opt_list
 *   Same as <list>, but there might be only one element in the list
 *
 *   Parameters:
 *     lns:lens - the lens to repeat in the list
 *     sep:lens - the separator lens, which can be taken from the <Sep> module
 ************************************************************************)
let opt_list (lns:lens) (sep:lens) = lns . ( sep . lns )*


(************************************************************************
 * Group:                   LABEL OPERATIONS
 ************************************************************************)

(************************************************************************
 * View: xchg
 *   Replace a pattern with a different label in the tree,
 *   thus emulating a key but allowing to replace the keyword
 *   with a different value than matched
 *
 *   Parameters:
 *     m:regexp - the pattern to match
 *     d:string - the default value when a node in created
 *     l:string - the label to apply for such nodes
 ************************************************************************)
let xchg (m:regexp) (d:string) (l:string) = del m d . label l

(************************************************************************
 * View: xchgs
 *   Same as <xchg>, but the pattern is the default string
 *
 *   Parameters:
 *     m:string - the string to replace, also used as default
 *     l:string - the label to apply for such nodes
 ************************************************************************)
let xchgs (m:string) (l:string) = xchg m m l


(************************************************************************
 * Group:                   SUBNODE CONSTRUCTIONS
 ************************************************************************)

(************************************************************************
 * View: key_value_line
 *   A subnode with a keyword, a separator and a storing lens,
 *   and an end of line
 *
 *   Parameters:
 *     kw:regexp - the pattern to match as key
 *     sep:lens  - the separator lens, which can be taken from the <Sep> module
 *     sto:lens  - the storing lens
 ************************************************************************)
let key_value_line (kw:regexp) (sep:lens) (sto:lens) =
                                   [ key kw . sep . sto . eol ]

(************************************************************************
 * View: key_value_line_comment
 *   Same as <key_value_line>, but allows to have a comment in the end of a line
 *   and an end of line
 *
 *   Parameters:
 *     kw:regexp    - the pattern to match as key
 *     sep:lens     - the separator lens, which can be taken from the <Sep> module
 *     sto:lens     - the storing lens
 *     comment:lens - the comment lens, which can be taken from <Util>
 ************************************************************************)
let key_value_line_comment (kw:regexp) (sep:lens) (sto:lens) (comment:lens) =
                                   [ key kw . sep . sto . (eol|comment) ]

(************************************************************************
 * View: key_value
 *   Same as <key_value_line>, but does not end with an end of line
 *
 *   Parameters:
 *     kw:regexp - the pattern to match as key
 *     sep:lens  - the separator lens, which can be taken from the <Sep> module
 *     sto:lens  - the storing lens
 ************************************************************************)
let key_value (kw: regexp) (sep:lens) (sto:lens) =
                                   [ key kw . sep . sto ]

(************************************************************************
 * View: key_ws_value
 *
 *   Store a key/value pair where key and value are separated by whitespace
 *   and the value goes to the end of the line. Leading and trailing
 *   whitespace is stripped from the value. The end of line is consumed by
 *   this lens
 *
 *   Parameters:
 *     kw:regexp - the pattern to match as key
 ************************************************************************)
let key_ws_value (kw:regexp) =
  key_value_line kw Util.del_ws_spc (store Rx.space_in)

(************************************************************************
 * View: flag
 *   A simple flag subnode, consisting of a single key
 *
 *   Parameters:
 *     kw:regexp - the pattern to match as key
 ************************************************************************)
let flag (kw:regexp) = [ key kw ]

(************************************************************************
 * View: flag_line
 *   A simple flag line, consisting of a single key
 *
 *   Parameters:
 *     kw:regexp - the pattern to match as key
 ************************************************************************)
let flag_line (kw:regexp) = [ key kw . eol ]


(************************************************************************
 * Group:                   BLOCK CONSTRUCTIONS
 ************************************************************************)

(************************************************************************
 * View: block_generic
 *   A block enclosed in brackets
 *
 *   Parameters:
 *     entry:lens                - the entry to be stored inside the block.
 *                                 This entry should include <Util.empty>
 *                                 or its equivalent if necessary.
 *     entry_noindent:lens       - the entry to be stored inside the block,
 *                                 without indentation.
 *                                 This entry should not include <Util.empty>
 *     entry_noeol:lens          - the entry to be stored inside the block,
 *                                 without eol.
 *                                 This entry should not include <Util.empty>
 *     entry_noindent_noeol:lens - the entry to be stored inside the block,
 *                                 without indentation or eol.
 *                                 This entry should not include <Util.empty>
 *     comment:lens              - the comment lens used in the block
 *     comment_noindent:lens     - the comment lens used in the block,
 *                                 without indentation.
 *     ldelim_re:regexp          - regexp for the left delimiter
 *     rdelim_re:regexp          - regexp for the right delimiter
 *     ldelim_default:string     - default value for the left delimiter
 *     rdelim_default:string     - default value for the right delimiter
 ************************************************************************)
let block_generic
     (entry:lens) (entry_noindent:lens)
     (entry_noeol:lens) (entry_noindent_noeol:lens)
     (comment:lens) (comment_noindent:lens)
     (ldelim_re:regexp) (rdelim_re:regexp)
     (ldelim_default:string) (rdelim_default:string) =
     let block_single = entry_noindent_noeol | comment_noindent
  in let block_start  = entry_noindent | comment_noindent
  in let block_middle = (entry | comment)*
  in let block_end    = entry_noeol | comment
  in del ldelim_re ldelim_default
     . ( ( block_start . block_middle . block_end )
       | block_single )
     . del rdelim_re rdelim_default

(************************************************************************
 * View: block_setdefault
 *   A block enclosed in brackets
 *
 *   Parameters:
 *     entry:lens - the entry to be stored inside the block.
 *                  This entry should not include <Util.empty>,
 *                  <Util.comment> or <Util.comment_noindent>,
 *                  should not be indented or finish with an eol.
 *     ldelim_re:regexp      - regexp for the left delimiter
 *     rdelim_re:regexp      - regexp for the left delimiter
 *     ldelim_default:string - default value for the left delimiter
 *     rdelim_default:string - default value for the right delimiter
 ************************************************************************)
let block_setdelim (entry:lens)
                     (ldelim_re:regexp)
                     (rdelim_re:regexp)
                     (ldelim_default:string)
                     (rdelim_default:string) =
    block_generic (Util.empty | Util.indent . entry . eol)
                  (entry . eol) (Util.indent . entry) entry
                  Util.comment Util.comment_noindent
                  ldelim_re rdelim_re
                  ldelim_default rdelim_default

(* Variable: block_ldelim_re *)
let block_ldelim_re = /[ \t\n]+\{[ \t\n]*/

(* Variable: block_rdelim_re *)
let block_rdelim_re = /[ \t\n]*\}/

(* Variable: block_ldelim_default *)
let block_ldelim_default = " {\n"

(* Variable: block_rdelim_default *)
let block_rdelim_default = "}"

(************************************************************************
 * View: block
 *   A block enclosed in brackets
 *
 *   Parameters:
 *     entry:lens - the entry to be stored inside the block.
 *                  This entry should not include <Util.empty>,
 *                  <Util.comment> or <Util.comment_noindent>,
 *                  should not be indented or finish with an eol.
 ************************************************************************)
let block (entry:lens) = block_setdelim entry
                         block_ldelim_re block_rdelim_re
                         block_ldelim_default block_rdelim_default

(* Variable: block_ldelim_newlines_re *)
let block_ldelim_newlines_re = /[ \t\n]+\{([ \t\n]*\n)?/

(* Variable: block_rdelim_newlines_re *)
let block_rdelim_newlines_re = /[ \t]*\}/

(* Variable: block_ldelim_newlines_default *)
let block_ldelim_newlines_default = "\n{\n"

(* Variable: block_rdelim_newlines_default *)
let block_rdelim_newlines_default = "}"

(************************************************************************
 * View: block_newline
 *   A block enclosed in brackets, with newlines forced
 *   and indentation defaulting to a tab.
 *
 *   Parameters:
 *     entry:lens - the entry to be stored inside the block.
 *                  This entry should not include <Util.empty>,
 *                  <Util.comment> or <Util.comment_noindent>,
 *                  should be indented and finish with an eol.
 ************************************************************************)
let block_newlines (entry:lens) (comment:lens) =
      let indent = del Rx.opt_space "\t"
   in del block_ldelim_newlines_re block_ldelim_newlines_default
 . ((entry | comment) . (Util.empty | entry | comment)*)?
 . del block_rdelim_newlines_re block_rdelim_newlines_default

(************************************************************************
 * View: named_block
 *   A named <block> enclosed in brackets
 *
 *   Parameters:
 *     kw:regexp  - the regexp for the block name
 *     entry:lens - the entry to be stored inside the block
 *                   this entry should not include <Util.empty>
 ************************************************************************)
let named_block (kw:regexp) (entry:lens) = [ key kw . block entry . eol ]


(************************************************************************
 * Group:               COMBINATORICS
 ************************************************************************)

(************************************************************************
 * View: combine_two_ord
 *   Combine two lenses, ensuring first lens is first
 *
 *   Parameters:
 *     a:lens - the first lens
 *     b:lens - the second lens
 ************************************************************************)
let combine_two_ord (a:lens) (b:lens) = a . b

(************************************************************************
 * View: combine_two
 *   Combine two lenses
 *
 *   Parameters:
 *     a:lens - the first lens
 *     b:lens - the second lens
 ************************************************************************)
let combine_two (a:lens) (b:lens) =
  combine_two_ord a b | combine_two_ord b a

(************************************************************************
 * View: combine_two_opt_ord
 *   Combine two lenses optionally, ensuring first lens is first
 *   (a, and optionally b)
 *
 *   Parameters:
 *     a:lens - the first lens
 *     b:lens - the second lens
 ************************************************************************)
let combine_two_opt_ord (a:lens) (b:lens) = a . b?

(************************************************************************
 * View: combine_two_opt
 *   Combine two lenses optionally
 *   (either a, b, or both, in any order)
 *
 *   Parameters:
 *     a:lens - the first lens
 *     b:lens - the second lens
 ************************************************************************)
let combine_two_opt (a:lens) (b:lens) =
  combine_two_opt_ord a b | combine_two_opt_ord b a

(************************************************************************
 * View: combine_three_ord
 *   Combine three lenses, ensuring first lens is first
 *   (a followed by either b, c, in any order)
 *
 *   Parameters:
 *     a:lens - the first lens
 *     b:lens - the second lens
 *     c:lens - the third lens
 ************************************************************************)
let combine_three_ord (a:lens) (b:lens) (c:lens) =
  combine_two_ord a (combine_two b c)

(************************************************************************
 * View: combine_three
 *   Combine three lenses
 *
 *   Parameters:
 *     a:lens - the first lens
 *     b:lens - the second lens
 *     c:lens - the third lens
 ************************************************************************)
let combine_three (a:lens) (b:lens) (c:lens) =
    combine_three_ord a b c
  | combine_three_ord b a c
  | combine_three_ord c b a


(************************************************************************
 * View: combine_three_opt_ord
 *   Combine three lenses optionally, ensuring first lens is first
 *   (a followed by either b, c, or any of them, in any order)
 *
 *   Parameters:
 *     a:lens - the first lens
 *     b:lens - the second lens
 *     c:lens - the third lens
 ************************************************************************)
let combine_three_opt_ord (a:lens) (b:lens) (c:lens) =
  combine_two_opt_ord a (combine_two_opt b c)

(************************************************************************
 * View: combine_three_opt
 *   Combine three lenses optionally
 *   (either a, b, c, or any of them, in any order)
 *
 *   Parameters:
 *     a:lens - the first lens
 *     b:lens - the second lens
 *     c:lens - the third lens
 ************************************************************************)
let combine_three_opt (a:lens) (b:lens) (c:lens) =
    combine_three_opt_ord a b c
  | combine_three_opt_ord b a c
  | combine_three_opt_ord c b a

APT Browse - Built by Thomas Orozco.