@nfdi4plants/arctrl 2.0.0-beta.2 → 2.0.0

package/fable_modules/YAMLicious.0.0.1/RegexActivePatterns.fs

@@ -0,0 +1,166 @@
+module YAMLicious.RegexActivePatterns
+
+open System.Text.RegularExpressions
+open YAMLiciousTypes
+open Preprocessing
+open Regex
+
+// Define the active pattern
+let (|Key|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s ->
+        let m = Regex.Match(s, KeyPattern)
+        if m.Success then 
+            let comment: int option = 
+                let v = m.Groups.["comment"].Value
+                if v = "" then None else Some (int v)
+            Some {| Comment = comment; Key = m.Groups.["key"].Value |}
+        else
+            None
+    | _ -> None
+
+// Define the active pattern
+let (|KeyValue|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s ->
+        let m = Regex.Match(s, KeyValuePattern)
+        if m.Success then 
+            let v: string =
+                m.Groups.["value"].Value.Trim() 
+            Some {| Value = v; Key = m.Groups.["key"].Value |}
+        else
+            None
+    | _ -> None
+
+// Define the active pattern
+let (|YamlValue|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s ->
+        let m = Regex.Match(s, ValuePattern)
+        if m.Success then 
+            let comment: int option = 
+                let v = m.Groups.["comment"].Value
+                if v = "" then None else Some (int v)
+            let v: string =
+                m.Groups.["value"].Value.Trim()
+            Some {| Comment = comment; Value = v |}
+        else
+            None
+    | _ -> None
+
+// Define the active pattern
+let (|YamlComment|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s ->
+        let m = Regex.Match(s, LineCommentPattern)
+        if m.Success then 
+            Some {| Comment = m.Groups.["comment"].Value |> int|}
+        else
+            None
+    | _ -> None
+
+// Define the active pattern
+let (|SequenceMinusOpener|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s -> 
+        let m = Regex.Match(s, SequenceMinusPattern) 
+        if m.Success then 
+            let v: string option =
+                let v = m.Groups.["value"].Value.Trim()
+                if v = "" then None else Some v
+            Some {| Value = v |}
+        else
+            None
+    | _ -> None
+
+let (|InlineSequence|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s -> 
+        let m = Regex.Match(s, InlineSequencePattern) 
+        if m.Success then 
+            let comment: int option = 
+                let v = m.Groups.["comment"].Value
+                if v = "" then None else Some (int v)
+            let v: string =
+                m.Groups.["inlineSequence"].Value 
+            Some {| Comment = comment; Value = v|}
+        else
+            None
+    | _ -> None
+
+let (|SequenceSquareOpener|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s -> 
+        let m = Regex.Match(s, SequenceOpenerPattern) 
+        if m.Success then 
+            let comment: int option = 
+                let v = m.Groups.["comment"].Value
+                if v = "" then None else Some (int v)
+            Some {| Comment = comment|}
+        else
+            None
+    | _ -> None
+
+let (|SequenceSquareCloser|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s -> 
+        let m = Regex.Match(s, SequenceCloserPattern) 
+        if m.Success then 
+            let comment: int option = 
+                let v = m.Groups.["comment"].Value
+                if v = "" then None else Some (int v)
+            Some {| Comment = comment|}
+        else
+            None
+    | _ -> None
+
+let (|InlineJSON|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s -> 
+        let m = Regex.Match(s, InlineJSONPattern) 
+        if m.Success then 
+            let comment: int option = 
+                let v = m.Groups.["comment"].Value
+                if v = "" then None else Some (int v)
+            let v: string =
+                m.Groups.["inlineSequence"].Value 
+            Some {| Comment = comment; Value = v|}
+        else
+            None
+    | _ -> None
+
+let (|JSONKeyOpener|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s -> 
+        let m = Regex.Match(s, JSONOpenerPattern) 
+        if m.Success then 
+            let comment: int option = 
+                let v = m.Groups.["comment"].Value
+                if v = "" then None else Some (int v)
+            Some {| Key = m.Groups.["key"].Value; Comment = comment|}
+        else
+            None
+    | _ -> None
+
+let (|JSONCloser|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s -> 
+        let m = Regex.Match(s, JSONCloserPattern) 
+        if m.Success then 
+            let comment: int option = 
+                let v = m.Groups.["comment"].Value
+                if v = "" then None else Some (int v)
+            Some {| Comment = comment|}
+        else
+            None
+    | _ -> None
+
+let (|SchemaNamespace|_|) (input: PreprocessorElement) =
+    match input with
+    | Line s -> 
+        let m = Regex.Match(s, SchemaNamespacePattern) 
+        if m.Success then 
+            Some {| Key = m.Groups.["key"].Value|}
+        else
+            None
+    | _ -> None

package/fable_modules/YAMLicious.0.0.1/RegexActivePatterns.fs.js

@@ -0,0 +1,225 @@
+import { create, match } from "../fable-library-js.4.16.0/RegExp.js";
+import { JSONCloserPattern, JSONOpenerPattern, InlineJSONPattern, SequenceCloserPattern, SequenceOpenerPattern, InlineSequencePattern, LineCommentPattern, ValuePattern, KeyPattern } from "./Regex.fs.js";
+import { unwrap } from "../fable-library-js.4.16.0/Option.js";
+import { parse } from "../fable-library-js.4.16.0/Int32.js";
+
+export function $007CKey$007C_$007C(input) {
+    let v;
+    if (input.tag === 2) {
+        const m = match(create(KeyPattern), input.fields[0]);
+        if (m != null) {
+            return {
+                Comment: unwrap((v = ((m.groups && m.groups.comment) || ""), (v === "") ? void 0 : parse(v, 511, false, 32))),
+                Key: (m.groups && m.groups.key) || "",
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CKeyValue$007C_$007C(input) {
+    if (input.tag === 2) {
+        const m = match(/^(?<key>[^\{{\[]+):\s+(?<value>(.*))$/gu, input.fields[0]);
+        if (m != null) {
+            const v = ((m.groups && m.groups.value) || "").trim();
+            return {
+                Key: (m.groups && m.groups.key) || "",
+                Value: v,
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CYamlValue$007C_$007C(input) {
+    let v;
+    if (input.tag === 2) {
+        const m = match(create(ValuePattern), input.fields[0]);
+        if (m != null) {
+            return {
+                Comment: unwrap((v = ((m.groups && m.groups.comment) || ""), (v === "") ? void 0 : parse(v, 511, false, 32))),
+                Value: ((m.groups && m.groups.value) || "").trim(),
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CYamlComment$007C_$007C(input) {
+    if (input.tag === 2) {
+        const m = match(create(LineCommentPattern), input.fields[0]);
+        if (m != null) {
+            return {
+                Comment: parse((m.groups && m.groups.comment) || "", 511, false, 32),
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CSequenceMinusOpener$007C_$007C(input) {
+    let v;
+    if (input.tag === 2) {
+        const m = match(/^-(\s+(?<value>.*))?$/gu, input.fields[0]);
+        if (m != null) {
+            return {
+                Value: unwrap((v = ((m.groups && m.groups.value) || "").trim(), (v === "") ? void 0 : v)),
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CInlineSequence$007C_$007C(input) {
+    let v;
+    if (input.tag === 2) {
+        const m = match(create(InlineSequencePattern), input.fields[0]);
+        if (m != null) {
+            return {
+                Comment: unwrap((v = ((m.groups && m.groups.comment) || ""), (v === "") ? void 0 : parse(v, 511, false, 32))),
+                Value: (m.groups && m.groups.inlineSequence) || "",
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CSequenceSquareOpener$007C_$007C(input) {
+    let v;
+    if (input.tag === 2) {
+        const m = match(create(SequenceOpenerPattern), input.fields[0]);
+        if (m != null) {
+            return {
+                Comment: unwrap((v = ((m.groups && m.groups.comment) || ""), (v === "") ? void 0 : parse(v, 511, false, 32))),
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CSequenceSquareCloser$007C_$007C(input) {
+    let v;
+    if (input.tag === 2) {
+        const m = match(create(SequenceCloserPattern), input.fields[0]);
+        if (m != null) {
+            return {
+                Comment: unwrap((v = ((m.groups && m.groups.comment) || ""), (v === "") ? void 0 : parse(v, 511, false, 32))),
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CInlineJSON$007C_$007C(input) {
+    let v;
+    if (input.tag === 2) {
+        const m = match(create(InlineJSONPattern), input.fields[0]);
+        if (m != null) {
+            return {
+                Comment: unwrap((v = ((m.groups && m.groups.comment) || ""), (v === "") ? void 0 : parse(v, 511, false, 32))),
+                Value: (m.groups && m.groups.inlineSequence) || "",
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CJSONKeyOpener$007C_$007C(input) {
+    let v;
+    if (input.tag === 2) {
+        const m = match(create(JSONOpenerPattern), input.fields[0]);
+        if (m != null) {
+            return {
+                Comment: unwrap((v = ((m.groups && m.groups.comment) || ""), (v === "") ? void 0 : parse(v, 511, false, 32))),
+                Key: (m.groups && m.groups.key) || "",
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CJSONCloser$007C_$007C(input) {
+    let v;
+    if (input.tag === 2) {
+        const m = match(create(JSONCloserPattern), input.fields[0]);
+        if (m != null) {
+            return {
+                Comment: unwrap((v = ((m.groups && m.groups.comment) || ""), (v === "") ? void 0 : parse(v, 511, false, 32))),
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function $007CSchemaNamespace$007C_$007C(input) {
+    if (input.tag === 2) {
+        const m = match(/^\$(?<key>[a-zA-Z0-9\s:]+):$/gu, input.fields[0]);
+        if (m != null) {
+            return {
+                Key: (m.groups && m.groups.key) || "",
+            };
+        }
+        else {
+            return void 0;
+        }
+    }
+    else {
+        return void 0;
+    }
+}
+

package/fable_modules/YAMLicious.0.0.1/Writer.fs

@@ -0,0 +1,84 @@
+module YAMLicious.Writer
+
+open YAMLicious.YAMLiciousTypes
+
+module StyleVerifier =
+    
+    let checkInlineSequence (ele: YAMLElement list) =
+        ele 
+        |> Seq.forall (fun x ->
+            match x with
+            | YAMLElement.Value {Value = v; Comment = None} ->
+                true
+            | _ -> false
+        )
+
+module Formatting =
+
+    let mkComment (comment: string) = "#" +  comment
+    let mkKey (key: string) = key + ":"
+    let mkContent (content: YAMLContent) = content.Value + (content.Comment |> Option.map (fun s -> " " + (mkComment s)) |> Option.defaultValue "")
+    let mkInlineSequence (seq: YAMLElement list) = 
+        let content = 
+            seq 
+            |> List.map (fun x -> 
+                match x with
+                | YAMLElement.Value {Value = v; Comment = None} -> v
+                | _ -> failwith "Invalid sequence element"
+            )
+            |> String.concat ", "
+        "[" + content + "]"
+    let mkMinusLine (c: string) = "- " + c
+
+let detokenize (ele: YAMLElement) =
+    let rec loop (ele: YAMLElement) =
+        match ele with
+        | YAMLElement.Nil ->
+            PreprocessorElement.Nil
+        | YAMLElement.Mapping (key, v) -> 
+            match v with
+            | YAMLElement.Value v -> // mykey: myvalue # 12313
+                let s = Formatting.mkKey key.Value + " " + Formatting.mkContent v
+                PreprocessorElement.Line s
+            | YAMLElement.Sequence seq when StyleVerifier.checkInlineSequence seq -> // mykey: [v1, v2, v3]
+                let s = Formatting.mkKey key.Value + " " + Formatting.mkInlineSequence seq
+                PreprocessorElement.Line s
+            | anyElse ->
+                PreprocessorElement.Level [
+                    PreprocessorElement.Line (Formatting.mkKey (Formatting.mkContent key))
+                    PreprocessorElement.Intendation [
+                        loop anyElse
+                    ]
+                ]
+        | YAMLElement.Value (v) -> 
+            PreprocessorElement.Line (Formatting.mkContent v)
+        | YAMLElement.Object seq ->
+            PreprocessorElement.Level [
+                for ele in seq do
+                    loop ele 
+            ]
+        | YAMLElement.Sequence seq -> 
+            PreprocessorElement.Level [
+                for ele in seq do
+                    match ele with
+                    | YAMLElement.Value v -> // mykey: myvalue # 12313
+                        let s = Formatting.mkMinusLine (Formatting.mkContent v)
+                        PreprocessorElement.Line s
+                    | YAMLElement.Sequence seq when StyleVerifier.checkInlineSequence seq -> // - [v1, v2, v3]
+                        let s = Formatting.mkMinusLine (Formatting.mkInlineSequence seq)
+                        PreprocessorElement.Line s
+                    | anyElse ->
+                        PreprocessorElement.Level [
+                            PreprocessorElement.Line "-"
+                            PreprocessorElement.Intendation [
+                                loop anyElse
+                            ]
+                        ]
+            ]
+        | YAMLElement.Comment (c) -> 
+            PreprocessorElement.Line (Formatting.mkComment c)
+    loop ele
+
+let write (ele: YAMLElement) (fconfig: (Config -> Config) option) =
+    let preprocessed = detokenize ele
+    Preprocessing.write (preprocessed, fconfig)

package/fable_modules/YAMLicious.0.0.1/Writer.fs.js

@@ -0,0 +1,161 @@
+import { singleton as singleton_1, collect, map as map_2, delay, toList, forAll } from "../fable-library-js.4.16.0/Seq.js";
+import { map, defaultArg } from "../fable-library-js.4.16.0/Option.js";
+import { join } from "../fable-library-js.4.16.0/String.js";
+import { ofArray, singleton, map as map_1 } from "../fable-library-js.4.16.0/List.js";
+import { PreprocessorElement } from "./YAMLiciousTypes.fs.js";
+import { write as write_1 } from "./Preprocessing.fs.js";
+
+export function StyleVerifier_checkInlineSequence(ele) {
+    return forAll((x) => {
+        let matchResult, v;
+        if (x.tag === 1) {
+            if (x.fields[0].Comment == null) {
+                matchResult = 0;
+                v = x.fields[0].Value;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return true;
+            default:
+                return false;
+        }
+    }, ele);
+}
+
+export function Formatting_mkComment(comment) {
+    return "#" + comment;
+}
+
+export function Formatting_mkKey(key) {
+    return key + ":";
+}
+
+export function Formatting_mkContent(content) {
+    return content.Value + defaultArg(map((s) => (" " + Formatting_mkComment(s)), content.Comment), "");
+}
+
+export function Formatting_mkInlineSequence(seq) {
+    return ("[" + join(", ", map_1((x) => {
+        let matchResult, v;
+        if (x.tag === 1) {
+            if (x.fields[0].Comment == null) {
+                matchResult = 0;
+                v = x.fields[0].Value;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return v;
+            default:
+                throw new Error("Invalid sequence element");
+        }
+    }, seq))) + "]";
+}
+
+export function Formatting_mkMinusLine(c) {
+    return "- " + c;
+}
+
+export function detokenize(ele) {
+    const loop = (ele_1) => {
+        switch (ele_1.tag) {
+            case 0: {
+                const v = ele_1.fields[1];
+                const key = ele_1.fields[0];
+                let matchResult, v_1, seq_1, anyElse;
+                switch (v.tag) {
+                    case 1: {
+                        matchResult = 0;
+                        v_1 = v.fields[0];
+                        break;
+                    }
+                    case 2: {
+                        if (StyleVerifier_checkInlineSequence(v.fields[0])) {
+                            matchResult = 1;
+                            seq_1 = v.fields[0];
+                        }
+                        else {
+                            matchResult = 2;
+                            anyElse = v;
+                        }
+                        break;
+                    }
+                    default: {
+                        matchResult = 2;
+                        anyElse = v;
+                    }
+                }
+                switch (matchResult) {
+                    case 0:
+                        return new PreprocessorElement(2, [(Formatting_mkKey(key.Value) + " ") + Formatting_mkContent(v_1)]);
+                    case 1:
+                        return new PreprocessorElement(2, [(Formatting_mkKey(key.Value) + " ") + Formatting_mkInlineSequence(seq_1)]);
+                    default:
+                        return new PreprocessorElement(0, [ofArray([new PreprocessorElement(2, [Formatting_mkKey(Formatting_mkContent(key))]), new PreprocessorElement(1, [singleton(loop(anyElse))])])]);
+                }
+            }
+            case 1:
+                return new PreprocessorElement(2, [Formatting_mkContent(ele_1.fields[0])]);
+            case 3:
+                return new PreprocessorElement(0, [toList(delay(() => map_2(loop, ele_1.fields[0])))]);
+            case 2:
+                return new PreprocessorElement(0, [toList(delay(() => collect((ele_3) => {
+                    const matchValue = ele_3;
+                    let matchResult_1, v_3, seq_5, anyElse_1;
+                    switch (matchValue.tag) {
+                        case 1: {
+                            matchResult_1 = 0;
+                            v_3 = matchValue.fields[0];
+                            break;
+                        }
+                        case 2: {
+                            if (StyleVerifier_checkInlineSequence(matchValue.fields[0])) {
+                                matchResult_1 = 1;
+                                seq_5 = matchValue.fields[0];
+                            }
+                            else {
+                                matchResult_1 = 2;
+                                anyElse_1 = matchValue;
+                            }
+                            break;
+                        }
+                        default: {
+                            matchResult_1 = 2;
+                            anyElse_1 = matchValue;
+                        }
+                    }
+                    switch (matchResult_1) {
+                        case 0:
+                            return singleton_1(new PreprocessorElement(2, [Formatting_mkMinusLine(Formatting_mkContent(v_3))]));
+                        case 1:
+                            return singleton_1(new PreprocessorElement(2, [Formatting_mkMinusLine(Formatting_mkInlineSequence(seq_5))]));
+                        default:
+                            return singleton_1(new PreprocessorElement(0, [ofArray([new PreprocessorElement(2, ["-"]), new PreprocessorElement(1, [singleton(loop(anyElse_1))])])]));
+                    }
+                }, ele_1.fields[0])))]);
+            case 4:
+                return new PreprocessorElement(2, [Formatting_mkComment(ele_1.fields[0])]);
+            default:
+                return new PreprocessorElement(3, []);
+        }
+    };
+    return loop(ele);
+}
+
+export function write(ele, fconfig) {
+    return write_1(detokenize(ele), fconfig);
+}
+

package/fable_modules/YAMLicious.0.0.1/YAMLicious.fableproj

@@ -0,0 +1,39 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Authors>Caroline Ott, Kevin Frey</Authors>
+    <Description>A encoder/decoder based YAML parser in Thoth.Json style!</Description>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <PackageTags>f# fsharp fable fable-library fable-javascript fable-python yaml parser</PackageTags>
+    <PackageProjectUrl>https://github.com/CSBiology/YAMLicious</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/CSBiology/YAMLicious</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="*.fsproj; **\*.fs; **\*.fsi" PackagePath="fable\" />
+    <None Include="..\..\README.md" Pack="true" PackagePath="\"/>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="Interop\PyInterop.fs" />
+    <Compile Include="Interop\JsInterop.fs" />
+    <Compile Include="YAMLiciousTypes.fs" />
+    <Compile Include="Persil.fs" />
+    <Compile Include="Preprocessing.fs" />
+    <Compile Include="Regex.fs" />
+    <Compile Include="RegexActivePatterns.fs" />
+    <Compile Include="Reader.fs" />
+    <Compile Include="Writer.fs" />
+    <Compile Include="Encode.fs" />
+    <Compile Include="Decode.fs" />
+    <Compile Include="Library.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Fable.Core" Version="4.3.0" />
+  </ItemGroup>
+
+</Project>