positional .strict() without requiring "--"?

[jamesyoungman]

I want to parse the initial options of "find" (-H, -L, -P, -E, -D) and return the remaining options for later processing. I tried this:

fn make_option_parser() -> OptionParser<(NameResolutionMode, DebugOptions, Vec<OsString>)> {
    let h = short('H')
        .help("dereference symbolic links on the command line")
        .req_flag(NameResolutionMode::H);
    let l = short('L')
        .help("dereference all symbolic links")
        .req_flag(NameResolutionMode::L);
    let p = short('P')
        .help("do not dereference symbolic links")
        .req_flag(NameResolutionMode::P);
    let debug = short('D')
        .help("selects debugging output; comma-separated liist of values")
        .argument::<String>("CATEGORIES")
        .parse(str_to_debug_options)
        .collect::<DebugOptions>();
    let traversal_options = construct!([h, l, p]).last().fallback(NameResolutionMode::P);
    let tail = positional::<OsString>("start point or predicate")
        .many()
        .strict();
    let option_parser = construct!(traversal_options, debug, tail)
        .to_options()
        .with_usage(|u| {
            let mut doc = Doc::default();
            doc.emphasis("Usage: ");
            doc.literal("find");
            doc.text(" ");
            doc.doc(&u);
            doc
        });
    option_parser
}

However, this is not correct as the use of ".stirct()" means that positional args are only recognised on the right of "--" which find must not require.

On the other hand, if I remove .struct, then " find -H -LPH -D tree -PL /tmp -H" incorrectly parses the final -H as an option instead of as a positional argument.

In case you're not already familiar with find, the -H -P and -L options all mutually override each other (they select a mode, basically). The -D option is additive (so -D tree,search and -D tree -D search have the same effect). Option processing should stop at the leftmost positional argument. After that there are positional arguments which may start with a "-". For example, -print and -name.

FWIW, the "find" example in the crate docs looks like it's irrelevant as it doesn't preserve the order of evaluation, as far as I can tell, and doesn't support these (HLPDE) options either.

[pacak]

You can try using any::<OsString, _, _>("start point or predicate", Some).anywhere() instead of strict.

[pacak]

    let tail = any::<OsString, _, _>("start point or predicate", Some)
        .anywhere()
        .many();

[jamesyoungman]

No, that doesn't work correctly for the same reason I stated above ("On the other hand..."). Specifically that the final -H in
-H -LPH -D tree -PL /tmp /var/tmp -H is treated as an option, while it should actually be treated as a positional argument (as it is to the right of another positional argument, /var/tmp).

IOW, run_inner actually returns

Ok(
    (
        H,
        DebugOptions {
            values: {
                Tree,
            },
        },
        [
            "/tmp",
            "/var/tmp",
        ],
    ),
)

but it should return

Ok(
    (
        L,
        DebugOptions {
            values: {
                Tree,
            },
        },
        [
            "/tmp",
            "/var/tmp",
            "-H",
        ],
    ),
)

[pacak]

Do you have the code available online? I can take a look at it.

…

On Wed, Jun 26, 2024, 13:41 James Youngman ***@***.***> wrote: No, that doesn't work correctly for the same reason I stated above ("On the other hand..."). Specifically that the final -H in -H -LPH -D tree -PL /tmp /var/tmp -H is treated as an option, while it should actually be treated as a positional argument (as it is to the right of another positional argument, /var/tmp). IOW, run_inner actually returns Ok( ( H, DebugOptions { values: { Tree, }, }, [ "/tmp", "/var/tmp", ], ), ) but it should return Ok( ( L, DebugOptions { values: { Tree, }, }, [ "/tmp", "/var/tmp", "-H", ], ), ) — Reply to this email directly, view it on GitHub <#364 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAAQFI4RJKOFF2PGALT4ZPTZJL4LHAVCNFSM6AAAAABJZSEP2GVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TQOBVGY3DO> . You are receiving this because you commented.Message ID: ***@***.***>

[jamesyoungman]

I created one for you to view. There are two branches. One ("main") uses getopt. There, option-parsing works correctly but everything is cumbersome as it doesn't support OsStr command-lines. The other branch ("jy/try_bpaf") uses bpaf but parses some command lines incorrectly (presumably because I don't understand how to use bpaf properly.).

https://github.com/jamesyoungman/findutils-rs/tree/jy/try_bpaf

"cargo test" should show you some problem cases. The "main" branch contains basically the same tests (though the details of the handling of &OsStr args are different).

[pacak]

Got a second to look at the test cases. Your initial attempt was correct and currently it is not possible (in a clear way) to do this kind of restriction, but I'm in a process of making a refactor to allow doing more or less what you want - #359. I'll try to finish experiments within a few days so I can at least give you some time estimation, shouldn't take too long. I'll ping you once I have something.

[pacak]

@jamesyoungman I pushed a right-adj branch which introduces a single start_adjacent() restriction - all the things in the inner parser must be consumed in a single adjacent block of items from the start (or from previously parsed items), so having a parser like this

let option_parsers = xxx.start_adjacent();
let tail = any::<OsString, _, _>("TAIL", Some).many();
let parser = construct!(option_parsers, tail)

makes sure parser in xxx parse all the things up to first item they can't parse - positional item in this case.

With this diff test about non strict items passes as expected. There are some broken tests, but that's because program name is missing.

--- a/src/lib/options.rs
+++ b/src/lib/options.rs
@@ -303,8 +303,11 @@ fn make_option_parser() -> OptionParser<(NameResolutionMode, DebugOptions, Vec<O
         .parse(str_to_debug_options)
         .collect::<DebugOptions>();
     let traversal_options = construct!([h, l, p]).last().fallback(NameResolutionMode::P);
-    let tail = positional::<OsString>("start point or predicate").many();
-    let option_parser = construct!(traversal_options, debug, tail)
+    let tail = any::<OsString, _, _>("start point or predicate", Some).many();
+
+    let opt = construct!(traversal_options, debug).start_adjacent();
+    construct!(opt, tail)
+        .map(|(a, b)| (a.0, a.1, b))
         .to_options()
         .with_usage(|u| {
             let mut doc = Doc::default();

Let me know if this works for you.