[augeas-devel] Matching key/value statement

[Yclept Nemo]

On Fri, Oct 30, 2015 at 4:13 AM, Mol, Xavier (SCC) <xavier.mol at kit.edu>
wrote:
> let match = [ Util.del_opt_ws . key  Rx.word . Sep.space_equal . (store
Rx.word)? . Util.comment_or_eol ]
>
> I haven't tested this, since you did not give a real word example either,
so try it for yourself.

Hi,

    let match = [ Util.del_opt_ws "" . key  Rx.word . Sep.space_equal .
Util.comment_or_eol ]

That is ambiguous concatenation - I removed "(store Rx.word)?" for clarity.

In the put direction augeas differentiates lenses using child nodes, and
nodes using key/value properties. This isn't documented and caused me lots
of grief. For example
    lenses, ambiguous:      [ (del "a" "a") | (del "b" "b") ]
    lenses, unambiguous:    [ (del "a" "a") | (del "b" "b" . [ label "bleh"
]) ]
    nodes, ambiguous:       [ label "a" . store /a/ ] | [ label "a" . store
/a/ . del / / " " ]
    nodes, unambiguous:     [ label "a" . store /a/ ] | ([ label "a" .
store /a/ . del / / " " ] . [ label "bleh" ])
    nodes, unambiguous:     [ label "a" . store /a/ ] | [ label "a" . del /
/ " " ]
This isn't some theoretical limitation, but a shortcoming of augeas.

In the above examples, creating null placeholder nodes renders lenses
unusable in the put direction [1], but unnecessary for this particular
problem. The solution - move the node ambiguities to the lens level, and
the lens ambiguities to the node level.

These equivalent statements are both ambiguous:
    Node-level ambiguities:
    let record  = [ key . spaces? . equal . spaces? ]
                | [ key . spaces? . equal . spaces? . comment ]
                | [ key . spaces? . equal . spaces? . value ]
                | [ key . spaces? . equal . spaces? . value . spaces? .
comment ]

    Lens-level ambiguities:
    let record  = [ key . spaces? . equal . spaces? . (comment | value |
(value . spaces? . comment))?

Merge the node-level ambiguities to create a lens without ambiguities:
    let record  = [ key . spaces? . equal . spaces? . comment? ]
                | [ key . spaces? . equal . spaces? . value . (spaces .
comment)? ]

Note the flattened equivalent still has lens-level ambiguities:
    let record  = [ key . spaces? . equal . spaces? . (comment? | value .
(spaces? . comment)?)

Anyway, the non-ambiguous version can be made easier to use via a
constructor, and the default valueless placeholder changed from "key = " to
"key =":
    let spaces              = /[ \t]+/ " "
    let spaces_none         = del /[ \t]*/ ""
    let recorder
        (prefix:lens)       =
        let template
            (suffix:lens)   = [ prefix . key . spaces? . equal . suffix ] in
        let suffix_empty    = spaces_none | (spaces? . comment) in
        let suffix_value    = spaces? . value . (spaces? . comment)? in
        let records         = template suffix_empty | template suffix_value
in
        records

But the version I want is actually:
    let record  = [ key . spaces? . equal . spaces_none ]
                | [ key . spaces? . equal . spaces? . comment ]
                | [ key . spaces? . equal . spaces? . value . spaces_none ]
                | [ key . spaces? . equal . spaces? . value . spaces? .
comment ]

Which simplifies to:
    let record  = [ key . spaces? . equal . (spaces_none | (spaces? .
comment)) ]
                | [ key . spaces? . equal . spaces? . value (spaces_none |
(spaces? . comment)) ]

And then, nicely without ambiguities, to:
    let record  = [ key . spaces? . equal . (spaces? . value)? .
(spaces_none | (spaces? . comment) ]

I'm going to update my ConfigObj lenses soon with functional examples.

Sincerely,

[1] @augeas-devs: placeholder nodes that are ignored in the put direction
would be *extremely* useful. Drawing inspiration from perl regexes, perhaps
using modifier syntax such as "[?>lens]".
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://listman.redhat.com/archives/augeas-devel/attachments/20151031/ed0e58be/attachment.htm>