GeneratedOpensLeakRegression.fs

//------------------------------------------------------------------------------
//        This code was generated by myriad.
//        Changes to this file will be lost when the code is regenerated.
//------------------------------------------------------------------------------







namespace ConsumePlugin.OpensLeakVictim

open WoofWare.Myriad.Plugins

/// Methods to parse arguments for the type LeakArgs
[<RequireQualifiedAccess ; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module LeakArgs =
    type private ParseState_LeakArgs =
        /// Ready to consume a key or positional arg
        | AwaitingKey
        /// Waiting to receive a value for the key we've already consumed
        | AwaitingValue of key : string

    let parse' (getEnvironmentVariable : string -> string option) (args : string list) : LeakArgs =
        let ArgParser_errors = ResizeArray ()

        let helpText () =
            [ (sprintf "%s  int32%s%s" (sprintf "--%s" "foo") "" "") ] |> String.concat "\n"

        let parser_LeftoverArgs : string ResizeArray = ResizeArray ()
        let mutable arg_0 : int option = None

        /// Processes the key-value pair, returning Error if no key was matched.
        /// If the key is an arg which can have arity 1, but throws when consuming that arg, we return Error(<the message>).
        /// This can nevertheless be a successful parse, e.g. when the key may have arity 0.
        let processKeyValue (key : string) (value : string) : Result<unit, string option> =
            if System.String.Equals (key, sprintf "--%s" "foo", System.StringComparison.OrdinalIgnoreCase) then
                match arg_0 with
                | Some x ->
                    sprintf
                        "Argument '%s' was supplied multiple times: %s and %s"
                        (sprintf "--%s" "foo")
                        (x.ToString ())
                        (value.ToString ())
                    |> ArgParser_errors.Add

                    Ok ()
                | None ->
                    try
                        arg_0 <- value |> (fun x -> System.Int32.Parse x) |> Some
                        Ok ()
                    with _ as exc ->
                        exc.Message |> Some |> Error
            else
                Error None

        /// Returns false if we didn't set a value.
        let setFlagValue (key : string) : bool = false

        let rec go (state : ParseState_LeakArgs) (args : string list) =
            match args with
            | [] ->
                match state with
                | ParseState_LeakArgs.AwaitingKey -> ()
                | ParseState_LeakArgs.AwaitingValue key ->
                    if setFlagValue key then
                        ()
                    else
                        sprintf
                            "Trailing argument %s had no value. Use a double-dash to separate positional args from key-value args."
                            key
                        |> ArgParser_errors.Add
            | "--" :: rest ->
                match state with
                | ParseState_LeakArgs.AwaitingKey -> ()
                | ParseState_LeakArgs.AwaitingValue key ->
                    if setFlagValue key then
                        ()
                    else
                        sprintf
                            "Trailing argument %s had no value. Use a double-dash to separate positional args from key-value args."
                            key
                        |> ArgParser_errors.Add

                parser_LeftoverArgs.AddRange (rest |> Seq.map (fun x -> x))
            | arg :: args ->
                match state with
                | ParseState_LeakArgs.AwaitingKey ->
                    if arg.StartsWith ("--", System.StringComparison.Ordinal) then
                        if arg = "--help" then
                            helpText () |> failwithf "Help text requested.\n%s"
                        else
                            let equals = arg.IndexOf (char 61)

                            if equals < 0 then
                                args |> go (ParseState_LeakArgs.AwaitingValue arg)
                            else
                                let key = arg.[0 .. equals - 1]
                                let value = arg.[equals + 1 ..]

                                match processKeyValue key value with
                                | Ok () -> go ParseState_LeakArgs.AwaitingKey args
                                | Error x ->
                                    match x with
                                    | None ->
                                        failwithf "Unable to process argument %s as key %s and value %s" arg key value
                                    | Some msg ->
                                        sprintf "%s (at arg %s)" msg arg |> ArgParser_errors.Add
                                        go ParseState_LeakArgs.AwaitingKey args
                    else
                        arg |> (fun x -> x) |> parser_LeftoverArgs.Add
                        go ParseState_LeakArgs.AwaitingKey args
                | ParseState_LeakArgs.AwaitingValue key ->
                    match processKeyValue key arg with
                    | Ok () -> go ParseState_LeakArgs.AwaitingKey args
                    | Error exc ->
                        if setFlagValue key then
                            go ParseState_LeakArgs.AwaitingKey (arg :: args)
                        else
                            match exc with
                            | None ->
                                failwithf "Unable to process supplied arg %s. Help text follows.\n%s" key (helpText ())
                            | Some msg -> msg |> ArgParser_errors.Add

        go ParseState_LeakArgs.AwaitingKey args

        let parser_LeftoverArgs =
            if 0 = parser_LeftoverArgs.Count then
                ()
            else
                parser_LeftoverArgs
                |> String.concat " "
                |> sprintf "There were leftover args: %s"
                |> ArgParser_errors.Add

                Unchecked.defaultof<_>

        let arg_0 =
            match arg_0 with
            | None ->
                sprintf "Required argument '%s' received no value" (sprintf "--%s" "foo")
                |> ArgParser_errors.Add

                Unchecked.defaultof<_>
            | Some x -> x

        if 0 = ArgParser_errors.Count then
            {
                Foo = arg_0
            }
        else
            ArgParser_errors |> String.concat "\n" |> failwithf "Errors during parse!\n%s"

    let parse (args : string list) : LeakArgs =
        parse' (System.Environment.GetEnvironmentVariable >> Option.ofObj) args