@nfdi4plants/arctrl 1.0.0-alpha6

package/FileSystem/DefaultGitignore.js

@@ -0,0 +1,3 @@
+
+export const dgi = "# ----- macos rules -----\r\n# taken from https://github.com/github/gitignore/blob/main/Global/macOS.gitignore\r\n# General\r\n.DS_Store\r\n.AppleDouble\r\n.LSOverride\r\n# Icon must end with two \\r\r\nIcon\r\n# Thumbnails\r\n._*\r\n# Files that might appear in the root of a volume\r\n.DocumentRevisions-V100\r\n.fseventsd\r\n.Spotlight-V100\r\n.TemporaryItems\r\n.Trashes\r\n.VolumeIcon.icns\r\n.com.apple.timemachine.donotpresent\r\n# Directories potentially created on remote AFP share\r\n.AppleDB\r\n.AppleDesktop\r\nNetwork Trash Folder\r\nTemporary Items\r\n.apdisk\r\n# ----- windows rules -----\r\n# taken from https://github.com/github/gitignore/blob/main/Global/Windows.gitignore\r\n# Windows thumbnail cache files\r\nThumbs.db\r\nThumbs.db:encryptable\r\nehthumbs.db\r\nehthumbs_vista.db\r\n# Dump file\r\n*.stackdump\r\n# Folder config file\r\n[Dd]esktop.ini\r\n# Recycle Bin used on file shares\r\n$RECYCLE.BIN/\r\n# Windows Installer files\r\n*.cab\r\n*.msi\r\n*.msix\r\n*.msm\r\n*.msp\r\n# Windows shortcuts\r\n*.lnk\r\n# ----- linux rules -----\r\n# taken from https://github.com/github/gitignore/blob/main/Global/Linux.gitignore\r\n*~\r\n# temporary files which can be created if a process still has a handle open of a deleted file\r\n.fuse_hidden*\r\n# KDE directory preferences\r\n.directory\r\n# Linux trash folder which might appear on any partition or disk\r\n.Trash-*\r\n# .nfs files are created when an open file is removed but is still being accessed\r\n.nfs*\r\n";
+

package/FileSystem/FileSystem.js

@@ -0,0 +1,53 @@
+import { defaultArg } from "../fable_modules/fable-library.4.1.4/Option.js";
+import { FileSystemTree_$reflection, FileSystemTree } from "./FileSystemTree.js";
+import { map, append } from "../fable_modules/fable-library.4.1.4/Array.js";
+import { Record } from "../fable_modules/fable-library.4.1.4/Types.js";
+import { Commit_$reflection } from "./Commit.js";
+import { record_type, array_type } from "../fable_modules/fable-library.4.1.4/Reflection.js";
+
+export class FileSystem extends Record {
+    constructor(Tree, History) {
+        super();
+        this.Tree = Tree;
+        this.History = History;
+    }
+    static create({ tree, history }) {
+        return new FileSystem(tree, defaultArg(history, []));
+    }
+    AddFile(path) {
+        const this$ = this;
+        return new FileSystem(this$.Tree.AddFile(path), this$.History);
+    }
+    static addFile(path) {
+        return (fs) => fs.AddFile(path);
+    }
+    static fromFilePaths(paths) {
+        const tree = FileSystemTree.fromFilePaths(paths);
+        return FileSystem.create({
+            tree: tree,
+        });
+    }
+    Union(other) {
+        const this$ = this;
+        const tree = this$.Tree.Union(other.Tree);
+        const history = append(this$.History, other.History);
+        return FileSystem.create({
+            tree: tree,
+            history: history,
+        });
+    }
+    Copy() {
+        const this$ = this;
+        const fstCopy = this$.Tree.Copy();
+        const historyCopy = map((x) => x, this$.History);
+        return FileSystem.create({
+            tree: fstCopy,
+            history: historyCopy,
+        });
+    }
+}
+
+export function FileSystem_$reflection() {
+    return record_type("ARCtrl.FileSystem.FileSystem", [], FileSystem, () => [["Tree", FileSystemTree_$reflection()], ["History", array_type(Commit_$reflection())]]);
+}
+

package/FileSystem/FileSystemTree.js

@@ -0,0 +1,223 @@
+import { unwrap, defaultArg } from "../fable_modules/fable-library.4.1.4/Option.js";
+import { append as append_1, choose, equalsWith, tail, head, map, tryFind } from "../fable_modules/fable-library.4.1.4/Array.js";
+import { singleton, append, delay, toArray } from "../fable_modules/fable-library.4.1.4/Seq.js";
+import { Array_distinct, Array_groupBy } from "../fable_modules/fable-library.4.1.4/Seq2.js";
+import { curry2, arrayHash, stringHash } from "../fable_modules/fable-library.4.1.4/Util.js";
+import { combineMany, split } from "./Path.js";
+import { empty, reverse, toArray as toArray_1, cons } from "../fable_modules/fable-library.4.1.4/List.js";
+import { Union } from "../fable_modules/fable-library.4.1.4/Types.js";
+import { union_type, array_type, string_type } from "../fable_modules/fable-library.4.1.4/Reflection.js";
+
+export class FileSystemTree extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["File", "Folder"];
+    }
+    get Name() {
+        const this$ = this;
+        let n;
+        if (this$.tag === 1) {
+            n = this$.fields[0];
+        }
+        else {
+            n = this$.fields[0];
+        }
+        return n;
+    }
+    get isFolder() {
+        const this$ = this;
+        return this$.tag === 1;
+    }
+    get isFile() {
+        const this$ = this;
+        return this$.tag === 0;
+    }
+    static get ROOT_NAME() {
+        return "root";
+    }
+    static createFile(name) {
+        return new FileSystemTree(0, [name]);
+    }
+    static createFolder(name, children) {
+        return new FileSystemTree(1, [name, defaultArg(children, [])]);
+    }
+    static createRootFolder(children) {
+        return new FileSystemTree(1, [FileSystemTree.ROOT_NAME, children]);
+    }
+    TryGetChildByName(name) {
+        const this$ = this;
+        return (this$.tag === 0) ? void 0 : tryFind((c) => (c.Name === name), this$.fields[1]);
+    }
+    static tryGetChildByName(name) {
+        return (fst) => fst.TryGetChildByName(name);
+    }
+    ContainsChildWithName(name) {
+        const this$ = this;
+        return (this$.tag === 0) ? false : this$.fields[1].some((c) => (c.Name === name));
+    }
+    static containsChildWithName(name) {
+        return (fst) => fst.ContainsChildWithName(name);
+    }
+    AddFile(path) {
+        const this$ = this;
+        const existingPaths = this$.ToFilePaths();
+        const filePaths = toArray(delay(() => append(singleton(path), delay(() => existingPaths))));
+        return FileSystemTree.fromFilePaths(filePaths);
+    }
+    static addFile(path) {
+        return (tree) => tree.AddFile(path);
+    }
+    static fromFilePaths(paths) {
+        const loop = (paths_1, parent) => {
+            const files = map((arg_1) => {
+                const arg = head(arg_1);
+                return FileSystemTree.createFile(arg);
+            }, paths_1.filter((p) => (p.length === 1)));
+            const folders = map((tupledArg) => {
+                const parent_1 = FileSystemTree.createFolder(tupledArg[0], []);
+                return loop(map(tail, tupledArg[1]), parent_1);
+            }, Array_groupBy(head, paths_1.filter((p_1) => (p_1.length > 1)), {
+                Equals: (x_3, y_2) => (x_3 === y_2),
+                GetHashCode: stringHash,
+            }));
+            if (parent.tag === 1) {
+                return FileSystemTree.createFolder(parent.fields[0], toArray(delay(() => append(files, delay(() => folders)))));
+            }
+            else {
+                return parent;
+            }
+        };
+        return loop(Array_distinct(map(split, paths), {
+            Equals: (x, y) => equalsWith((x_1, y_1) => (x_1 === y_1), x, y),
+            GetHashCode: arrayHash,
+        }), FileSystemTree.createFolder(FileSystemTree.ROOT_NAME, []));
+    }
+    ToFilePaths(removeRoot) {
+        const this$ = this;
+        const res = [];
+        const loop = (output, parent) => {
+            if (parent.tag === 1) {
+                parent.fields[1].forEach((filest) => {
+                    loop(cons(parent.fields[0], output), filest);
+                });
+            }
+            else {
+                const arg = combineMany(toArray_1(reverse(cons(parent.fields[0], output))));
+                void (res.push(arg));
+            }
+        };
+        if (defaultArg(removeRoot, true)) {
+            if (this$.tag === 0) {
+                void (res.push(this$.fields[0]));
+            }
+            else {
+                const action_1 = curry2(loop)(empty());
+                this$.fields[1].forEach(action_1);
+            }
+        }
+        else {
+            loop(empty(), this$);
+        }
+        return Array.from(res);
+    }
+    static toFilePaths(removeRoot) {
+        return (root) => root.ToFilePaths(unwrap(removeRoot));
+    }
+    FilterFiles(predicate) {
+        const this$ = this;
+        const loop = (parent) => {
+            if (parent.tag === 1) {
+                return new FileSystemTree(1, [parent.fields[0], choose(loop, parent.fields[1])]);
+            }
+            else {
+                const n = parent.fields[0];
+                if (predicate(n)) {
+                    return new FileSystemTree(0, [n]);
+                }
+                else {
+                    return void 0;
+                }
+            }
+        };
+        return loop(this$);
+    }
+    static filterFiles(predicate) {
+        return (tree) => tree.FilterFiles(predicate);
+    }
+    FilterFolders(predicate) {
+        const this$ = this;
+        const loop = (parent) => {
+            if (parent.tag === 1) {
+                const n_1 = parent.fields[0];
+                if (predicate(n_1)) {
+                    return new FileSystemTree(1, [n_1, choose(loop, parent.fields[1])]);
+                }
+                else {
+                    return void 0;
+                }
+            }
+            else {
+                return new FileSystemTree(0, [parent.fields[0]]);
+            }
+        };
+        return loop(this$);
+    }
+    static filterFolders(predicate) {
+        return (tree) => tree.FilterFolders(predicate);
+    }
+    Filter(predicate) {
+        const this$ = this;
+        const loop = (parent) => {
+            if (parent.tag === 1) {
+                const n_1 = parent.fields[0];
+                if (predicate(n_1)) {
+                    const filteredChildren = choose(loop, parent.fields[1]);
+                    if (filteredChildren.length === 0) {
+                        return void 0;
+                    }
+                    else {
+                        return new FileSystemTree(1, [n_1, filteredChildren]);
+                    }
+                }
+                else {
+                    return void 0;
+                }
+            }
+            else {
+                const n = parent.fields[0];
+                if (predicate(n)) {
+                    return new FileSystemTree(0, [n]);
+                }
+                else {
+                    return void 0;
+                }
+            }
+        };
+        return loop(this$);
+    }
+    static filter(predicate) {
+        return (tree) => tree.Filter(predicate);
+    }
+    Union(otherFST) {
+        let array_1;
+        const this$ = this;
+        const arg = Array_distinct((array_1 = this$.ToFilePaths(), append_1(otherFST.ToFilePaths(), array_1)), {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        });
+        return FileSystemTree.fromFilePaths(arg);
+    }
+    Copy() {
+        const this$ = this;
+        return (this$.tag === 0) ? (new FileSystemTree(0, [this$.fields[0]])) : (new FileSystemTree(1, [this$.fields[0], map((c) => c.Copy(), this$.fields[1])]));
+    }
+}
+
+export function FileSystemTree_$reflection() {
+    return union_type("ARCtrl.FileSystem.FileSystemTree", [], FileSystemTree, () => [[["name", string_type]], [["name", string_type], ["children", array_type(FileSystemTree_$reflection())]]]);
+}
+

package/FileSystem/Path.js

@@ -0,0 +1,38 @@
+import { trim, join, trimStart, trimEnd, split as split_1 } from "../fable_modules/fable-library.4.1.4/String.js";
+import { last, mapIndexed } from "../fable_modules/fable-library.4.1.4/Array.js";
+
+export const seperators = ["/", "\\"];
+
+export function split(path) {
+    return split_1(path, seperators, void 0, 3);
+}
+
+export function combine(path1, path2) {
+    return (trimEnd(path1, ...seperators) + "/") + trimStart(path2, ...seperators);
+}
+
+export function combineMany(paths) {
+    return join("/", mapIndexed((i, p) => {
+        if (i === 0) {
+            return trimEnd(p, ...seperators);
+        }
+        else if (i === (paths.length - 1)) {
+            return trimStart(p, ...seperators);
+        }
+        else {
+            return trim(p, ...seperators);
+        }
+    }, paths));
+}
+
+export function getFileName(path) {
+    return last(split(path));
+}
+
+/**
+ * Checks if `path` points to a file with the name `fileName`
+ */
+export function isFile(fileName, path) {
+    return getFileName(path) === fileName;
+}
+

package/FileSystemTree.js

@@ -0,0 +1,51 @@
+import { FileSystemTree } from "./FileSystem/FileSystemTree.js";
+import { append } from "./fable_modules/fable-library.4.1.4/Array.js";
+
+export function createGitKeepFile() {
+    return FileSystemTree.createFile(".gitkeep");
+}
+
+export function createReadmeFile() {
+    return FileSystemTree.createFile("README.md");
+}
+
+export function createEmptyFolder(name) {
+    return FileSystemTree.createFolder(name, [createGitKeepFile()]);
+}
+
+export function createAssayFolder(assayName) {
+    const dataset = createEmptyFolder("dataset");
+    const protocols = createEmptyFolder("protocols");
+    const readme = createReadmeFile();
+    const assayFile = FileSystemTree.createFile("isa.assay.xlsx");
+    return FileSystemTree.createFolder(assayName, [dataset, protocols, assayFile, readme]);
+}
+
+export function createStudyFolder(studyName) {
+    const resources = createEmptyFolder("resources");
+    const protocols = createEmptyFolder("protocols");
+    const readme = createReadmeFile();
+    const studyFile = FileSystemTree.createFile("isa.study.xlsx");
+    return FileSystemTree.createFolder(studyName, [resources, protocols, studyFile, readme]);
+}
+
+export function createInvestigationFile() {
+    return FileSystemTree.createFile("isa.investigation.xlsx");
+}
+
+export function createAssaysFolder(assays) {
+    return FileSystemTree.createFolder("assays", append([createGitKeepFile()], assays));
+}
+
+export function createStudiesFolder(studies) {
+    return FileSystemTree.createFolder("studies", append([createGitKeepFile()], studies));
+}
+
+export function createWorkflowsFolder(workflows) {
+    return FileSystemTree.createFolder("workflows", append([createGitKeepFile()], workflows));
+}
+
+export function createRunsFolder(runs) {
+    return FileSystemTree.createFolder("runs", append([createGitKeepFile()], runs));
+}
+