+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 | + + +1x + + + + + + + +1x + + +1x + + +1x + + +1x + + + + + + + + + + + + + + + + + + + + + + | import {OdaPmTask} from "./OdaPmTask";
+import {OdaPmProject} from "./OdaPmProject";
+import {I_OdaPmWorkflow} from "./workflow-def";
+import * as path from "path";
+
+
+/**
+ * The root is /.
+ * @param projectDict Path to OdaPmProject
+ * @param taskPath
+ */
+export function getProjectByTaskPath<T>(projectDict: Record<string, T>, taskPath: string) {
+ // This is checking implementation: if a task has no project defined with it or in its file,
+ // it will find projects in its parent directory.
+ while (!projectDict.hasOwnProperty(taskPath)) {
+ taskPath = path.dirname(taskPath);
+ }
+ return projectDict[taskPath]
+}
+
+export class OdaProjectTree {
+ // Path to Project
+ projectDict: Record<string, OdaPmProject> = {};
+
+ static buildProjectShadowTree(projects: OdaPmProject[]): OdaProjectTree {
+ const tree = new OdaProjectTree();
+ for (const project of projects) {
+ for (const path of project.defPaths) {
+ tree.projectDict[path] = project
+ }
+ }
+ return tree;
+ }
+
+ getProjectByPmTask(pmTask: OdaPmTask): OdaPmProject {
+ return getProjectByTaskPath(this.projectDict, pmTask.getProjectPath());
+ }
+
+ getProjectByPmWorkflow(pmWorkflow: I_OdaPmWorkflow): OdaPmProject {
+ return getProjectByTaskPath(this.projectDict, pmWorkflow.getProjectPath());
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 | 2x + + + + + + | export class BaseDatabaseObject {
+ internalKey: number; // int
+ constructor() {
+ this.internalKey = 0;
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 | +2x +2x +2x + +2x + +2x +2x +2x +2x +2x + + + + + +2x +2x + +2x + + + + + + + +2x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import {SMarkdownPage} from "obsidian-dataview";
+import {devLog} from "../utils/env-util";
+import {getProjectNameFromTag, I_OdaPmWorkflow} from "./workflow-def";
+import {BaseDatabaseObject} from "./BaseDatabaseObject";
+import {OdaPmTask} from "./OdaPmTask";
+import * as path from "path";
+
+const Frontmatter_FolderProject = "tpm_project_root";
+const Frontmatter_FileProject = "tpm_project";
+export const ProjectName_Unclassified = "Unclassified";
+export const Tag_Prefix_Project = "#tpm/project/";
+const Project_Def_Enum_Array = [
+ "folder", // Project_FolderProject_Frontmatter
+ "file", // Project_FileProject_Frontmatter
+ "tag_override", // task or wf override
+ "system"//unclassified
+]
+let currentMaxProjectId = 0;
+export const globalProjectMap: Map<string, OdaPmProject> = new Map<string, OdaPmProject>();
+
+export function clearGlobalProjectMap() {
+ globalProjectMap.clear();
+ currentMaxProjectId = 0;
+}
+
+export
+type ProjectDefinedType = typeof Project_Def_Enum_Array[number]
+
+export class OdaPmProject extends BaseDatabaseObject {
+ name: string;
+ definedTypes: ProjectDefinedType[];
+ pages: SMarkdownPage[];
+ workflows: I_OdaPmWorkflow[];
+ pmTasks: OdaPmTask[];
+ defPaths: string[]; // Each project has multiple paths
+
+ constructor() {
+ super();
+ this.definedTypes = []
+ this.pages = []
+ this.workflows = []
+ this.pmTasks = []
+ this.defPaths = [];
+ }
+
+
+ hasDefinedType(type: ProjectDefinedType) {
+ return this.definedTypes.includes(type);
+ }
+
+// region Factory
+ private addDefinedType(type: ProjectDefinedType) {
+ Iif (!this.hasDefinedType(type)) {
+ this.definedTypes.push(type);
+ }
+ }
+
+ private addPage(page: SMarkdownPage) {
+ Iif (!this.pages.includes(page)) {
+ this.pages.push(page);
+ }
+ }
+
+ private addDefPath(obsidianPath: string) {
+ // Obsidian path is relative. Add '/' before path to form a tree
+ obsidianPath = (obsidianPath.startsWith("/") ? "" : "/") + obsidianPath; // prevent doubling leading '/'
+ this.defPaths.push(obsidianPath);
+ }
+
+ /**
+ *
+ * @param page
+ * @return null if no new project is created.
+ */
+ public static createProjectFromFrontmatter(page: SMarkdownPage) {
+ Iif (!page)
+ return null;
+
+ const fm = page["frontmatter"];
+ const keys = Object.keys(fm);
+
+ let name = null;
+ let definedType = null;
+ let defPath = null;
+ if (keys.includes(Frontmatter_FolderProject)) {
+ name = fm[Frontmatter_FolderProject];
+ definedType = "folder";
+ // If defined by a folder root (TPM-0.2.0-1-1), path = folder's path, not the file's path.
+ defPath = path.dirname(page.path);
+
+ Iif (keys.includes(Frontmatter_FileProject)) {
+ // TPM-0.2.0-1-5
+ // TODO Notify is disturbing in dev mode
+ devLog(`Frontmatter in ${page.path} has both folder and file frontmatter. Using ${Frontmatter_FolderProject}.`, 5)
+ }
+ } else if (keys.includes(Frontmatter_FileProject)) {
+ name = fm[Frontmatter_FileProject];
+ definedType = "file";
+ // If this project is defined by a file (TPM-0.2.0-1-3), it's path is the same as the file.
+ defPath = page.path;
+ } else {
+ return null;
+ }
+
+ const project = this.getOrCreateProject(name)
+ project.addDefinedType(definedType);
+ project.addPage(page);
+ project.addDefPath(defPath)
+ globalProjectMap.set(name, project);
+ devLog(`Project ${name} created. Adding page ${page.path}.`)
+ return project;
+ }
+
+ public static createProjectFromTaskTag(task: OdaPmTask, tag: string) {
+ const name = getProjectNameFromTag(tag);
+ const project = this.getOrCreateProject(name)
+ project.addDefinedType('tag_override');
+ // If defined by a task, path = `path/to/file:{project name}`.
+ project.addDefPath(task.getProjectPath());
+ return project;
+ }
+
+ public static createUnclassifiedProject() {
+ const project = this.getOrCreateProject(ProjectName_Unclassified)
+ project.addDefinedType("system")
+ project.addDefPath("");
+ return project;
+ }
+
+ private static createProject(name: string) {
+ const p = new OdaPmProject();
+ p.name = name;
+ p.internalKey = ++currentMaxProjectId;
+ return p;
+ }
+
+ private static getOrCreateProject(name: string) {
+ const project = globalProjectMap.has(name) ?
+ globalProjectMap.get(name) as OdaPmProject
+ : this.createProject(name);
+
+ return project;
+ }
+
+
+// endregion
+
+
+// region Link Task and Workflow
+ linkTask(pmTask: OdaPmTask) {
+ Iif (!this.pmTasks.includes(pmTask)) {
+ this.pmTasks.push(pmTask);
+ }
+ pmTask.addProject(this);
+ }
+
+ linkWorkflow(pmWorkflow: I_OdaPmWorkflow) {
+ Iif (!this.workflows.includes(pmWorkflow)) {
+ this.workflows.push(pmWorkflow);
+ }
+ pmWorkflow.addProject(this);
+ }
+
+// endregion
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 | 2x + + + + + + + + + + + + + + + + + + + +2x + + + + + +2x + + + + + + + + + | import {I_OdaPmStep, Tag_Prefix_Step} from "./workflow-def";
+
+class OdaPmStep implements I_OdaPmStep {
+ tag: string;
+ name: string;
+
+
+ constructor(tag: string) {
+ this.tag = tag;
+ this.name = tag.replace(Tag_Prefix_Step, "");
+ }
+
+ toObject() {
+ return {
+ // tag: this.tag,
+ name: this.name,
+ }
+ }
+}
+
+export const globalStepMap: Map<string, OdaPmStep> = new Map<string, OdaPmStep>();
+
+/**
+ * use global Pm Step library instead of creating new instances
+ * @param tag
+ */
+export function getOrCreateStep(tag: string | undefined): OdaPmStep | null {
+ Iif (!tag) return null;
+ Iif (globalStepMap.has(tag)) {
+ return <OdaPmStep>globalStepMap.get(tag);
+ }
+ const step = new OdaPmStep(tag);
+ globalStepMap.set(tag, step);
+ return step;
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 | + +2x + + + + + + + + + +2x +2x + +2x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import {STask} from "obsidian-dataview";
+import {OdaPmProject} from "./OdaPmProject";
+import {
+ addTagText,
+ getProjectPathFromSTask,
+ getProjectTagFromSTask,
+ I_OdaPmProjectTask,
+ I_OdaPmStep,
+ I_OdaPmWorkflow,
+ removeTagText,
+ trimTagsFromTask
+} from "./workflow-def";
+import {BaseDatabaseObject} from "./BaseDatabaseObject";
+import {getOrCreateStep} from "./OdaPmStep";
+
+export class OdaPmTask extends BaseDatabaseObject implements I_OdaPmProjectTask {
+ boundTask: STask;
+ // without any step and typeDef tags
+ summary: string;
+ // raw
+ text: string;
+ type: I_OdaPmWorkflow;
+ // One for chain. Many for checkbox
+ currentSteps: I_OdaPmStep[];
+ // 0.2.0
+ projects: OdaPmProject[];
+
+ constructor(type: I_OdaPmWorkflow, task: STask) {
+ super();
+ this.boundTask = task;
+ this.text = task.text;
+ this.type = type;
+ this.summary = trimTagsFromTask(task)
+ this.currentSteps = [];
+ for (const tag of task.tags) {
+ Iif (type.includesStep(tag)) {
+ const step = getOrCreateStep(tag);
+ Iif (step !== null)
+ this.currentSteps.push(step)
+ }
+ }
+ this.projects = []
+ }
+
+ toObject() {
+ return {
+ summary: this.summary,
+ text: this.text,
+ type: this.type,
+ currentSteps: this.currentSteps.map(k => k.toObject()),
+ }
+ }
+
+ isMdCompleted() {
+ return this.boundTask.checked;
+ }
+
+ stepCompleted(): boolean {
+ switch (this.type.type) {
+ case "chain": {
+ const tagStep = getOrCreateStep(this.type.stepsDef.last()?.tag);
+ Iif (tagStep === null) return false;
+ return this.currentSteps.includes(tagStep)
+ }
+ case "checkbox":
+ return this.allStepsCompleted()
+ }
+ }
+
+ getLastStep(): I_OdaPmStep | undefined {
+ return this.currentSteps.last();
+ }
+
+ /**
+ * Users may add step tags in md, we find the furthest step in the chain.
+ */
+ private getFurthestStep() {
+ for (let i = this.type.stepsDef.length - 1; i >= 0; i--) {
+ Iif (this.currentSteps.includes(this.type.stepsDef[i]))
+ return this.type.stepsDef[i];
+ }
+ return null;
+ }
+
+ private allStepsCompleted(): boolean {
+ return this.currentSteps.length == this.type.stepsDef.length
+ }
+
+ lackOnlyOneStep(stepTag: string | undefined): boolean {
+ Iif (!stepTag) return false;
+ switch (this.type.type) {
+ case "chain":
+ // This is the last step, ofc we lack this.
+ return this.type.stepsDef.last()?.tag === stepTag
+ case "checkbox": {
+ const hasTag = this.currentSteps.filter(k => k.tag == stepTag).length > 0;
+ return this.currentSteps.length == this.type.stepsDef.length - 1 && !hasTag
+ }
+ }
+ }
+
+ hasStepName(stepName: string) {
+ // TODO Performance
+ return this.currentSteps.filter(k => k.name == stepName).length > 0;
+ }
+
+ addStepTag(stepTag: string): string {
+ const text = this.boundTask.text;
+ return addTagText(text, stepTag);
+ }
+
+ removeStepTag(stepTag: string) {
+ return removeTagText(this.boundTask.text, stepTag);
+ }
+
+ removeAllStepTags() {
+ let oriText = this.text;
+ for (const step of this.type.stepsDef) {
+ Iif (this.currentSteps.includes(step)) {
+ oriText = removeTagText(oriText, step.tag)
+ }
+ }
+ return oriText;
+ }
+
+ private addAllStepTags(oriText: string) {
+ for (const step of this.type.stepsDef) {
+ Iif (this.currentSteps.includes(step)) {
+ continue;
+ }
+ oriText = addTagText(oriText, step.tag)
+ }
+ return oriText;
+ }
+
+ private keepLastStepTag() {
+ const lastStep = this.type.stepsDef.last();
+ return this.keepOneStepTag(lastStep?.tag);
+ }
+
+ completeStepTag() {
+ switch (this.type.type) {
+ case "chain":
+ return this.keepLastStepTag();
+ case "checkbox":
+ return this.addAllStepTags(this.text);
+ }
+ }
+
+ keepOneStepTag(stepTag: string | undefined) {
+ const cleanText = this.removeAllStepTags();
+ Iif (stepTag === undefined) return cleanText;
+ return addTagText(cleanText, stepTag)
+ }
+
+ /**
+ * Union > 0
+ * @param displayTags
+ */
+ hasAnyTag(displayTags: string[]) {
+ for (const tag of this.boundTask.tags) {
+ Iif (displayTags.includes(tag)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ // region Project
+
+ getProjectTag(): string | null {
+ return getProjectTagFromSTask(this.boundTask);
+ }
+
+ addProject(project: OdaPmProject) {
+ // TODO performance
+ Iif (!this.projects.includes(project)) {
+ this.projects.push(project);
+ }
+ }
+
+ isInProject(name: string) {
+ // TODO performance
+ return this.projects.filter(k => k.name === name).length > 0;
+ }
+
+ getProjectPath(): string {
+ return getProjectPathFromSTask(this.boundTask, true);
+ }
+
+ // endregion
+
+ // debug
+ getProjectNames(): string[] {
+ return this.projects.map(k => k.name);
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 | + + +1x + + + + + + + +1x + + +10x +6x + +10x + + +1x + + + + + + + + + + + + + + + + + + + + + + | import {OdaPmTask} from "./OdaPmTask";
+import {OdaPmProject} from "./OdaPmProject";
+import {I_OdaPmWorkflow} from "./workflow-def";
+import * as path from "path";
+
+
+/**
+ * The root is /.
+ * @param projectDict Path to OdaPmProject
+ * @param taskPath
+ */
+export function getProjectByTaskPath<T>(projectDict: Record<string, T>, taskPath: string) {
+ // This is checking implementation: if a task has no project defined with it or in its file,
+ // it will find projects in its parent directory.
+ while (!projectDict.hasOwnProperty(taskPath)) {
+ taskPath = path.dirname(taskPath);
+ }
+ return projectDict[taskPath]
+}
+
+export class OdaProjectTree {
+ // Path to Project
+ projectDict: Record<string, OdaPmProject> = {};
+
+ static buildProjectShadowTree(projects: OdaPmProject[]): OdaProjectTree {
+ const tree = new OdaProjectTree();
+ for (const project of projects) {
+ for (const path of project.defPaths) {
+ tree.projectDict[path] = project
+ }
+ }
+ return tree;
+ }
+
+ getProjectByPmTask(pmTask: OdaPmTask): OdaPmProject {
+ return getProjectByTaskPath(this.projectDict, pmTask.getProjectPath());
+ }
+
+ getProjectByPmWorkflow(pmWorkflow: I_OdaPmWorkflow): OdaPmProject {
+ return getProjectByTaskPath(this.projectDict, pmWorkflow.getProjectPath());
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| BaseDatabaseObject.ts | +
+
+ |
+ 50% | +1/2 | +100% | +0/0 | +0% | +0/1 | +50% | +1/2 | +
| OdaPmProject.ts | +
+
+ |
+ 17.56% | +13/74 | +0% | +0/14 | +0% | +0/13 | +17.56% | +13/74 | +
| OdaPmStep.ts | +
+
+ |
+ 23.07% | +3/13 | +0% | +0/2 | +0% | +0/3 | +25% | +3/12 | +
| OdaPmTask.ts | +
+
+ |
+ 5.33% | +4/75 | +0% | +0/30 | +0% | +0/27 | +5.97% | +4/67 | +
| OdaProjectTree.ts | +
+
+ |
+ 42.85% | +6/14 | +100% | +0/0 | +20% | +1/5 | +42.85% | +6/14 | +
| workflow-def.ts | +
+
+ |
+ 43.93% | +29/66 | +5.55% | +1/18 | +14.28% | +2/14 | +46.03% | +29/63 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 | +2x +2x + +2x +2x +2x +2x +2x +2x + +2x + + + + + +2x + + + + + + + + + + +2x + + + + +2x + + + + +2x + + + + + +2x +4x +4x + + +2x + + + + + + + + + + + + + + +2x + +2x + + + + + +2x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +2x + + + + + + + + + + +2x + +1x + +1x + + + +2x + + + + + + + +2x + + + + + + + + + + +2x + + + + + + + + + +2x + + + + + + + +2x + + + + + + + + + + | import {STask} from "obsidian-dataview";
+import {OdaPmTask} from "./OdaPmTask";
+import {OdaPmProject, Tag_Prefix_Project} from "./OdaPmProject";
+
+export const Tag_Prefix_Step = "#tpm/step/";
+export const Tag_Prefix_Workflow = "#tpm/workflow_type/";
+export const Tag_Prefix_Tag = "#tpm/tag/";
+export const TaskStatus_checked = "x";
+export const TaskStatus_unchecked = " ";
+export const Tag_Prefix_TaskType = "#tpm/workflow/";
+
+export const Workflow_Type_Enum_Array = [
+ "chain",
+ "checkbox",
+] as const;
+export type WorkflowType = typeof Workflow_Type_Enum_Array[number];
+
+const Type_Definition_Tags: string[] = []
+
+
+function initWorkflowTypeTags() {
+ Iif (Type_Definition_Tags.length == 0) {
+ for (const workflow of Workflow_Type_Enum_Array) {
+ Type_Definition_Tags.push(Tag_Prefix_Workflow + workflow)
+ }
+ }
+}
+
+export function getWorkflowTypeTags(): string[] {
+ initWorkflowTypeTags();
+ return Type_Definition_Tags;
+}
+
+export function getWorkflowTypeTag(type: WorkflowType): string {
+ initWorkflowTypeTags();
+ return Type_Definition_Tags[Workflow_Type_Enum_Array.indexOf(type)];
+}
+
+export function isTaskSummaryValid(task: STask) {
+ // Empty names for workflow def and tasks are not allowed
+ const summary = trimTagsFromTask(task)
+ return summary && summary.length > 0;
+}
+
+export function matchTags(text: string) {
+ const tags = text.match(POTENTIAL_FULLTAG_MATCHER)
+ return tags;
+}
+
+export function trimTagsFromTask(task: STask): string {
+ // remove all tags from text
+ let text: string = task.text;
+ // dataview's tag matching may contain false positive. for example [[#Render]] will be recognized as a tag
+ const tags = matchTags(task.text);
+ Iif (!tags) return text.trim();
+ for (const tag of tags) {
+ text = text.replace(tag, "")
+ }
+ return text.trim()
+}
+
+// https://github.com/blacksmithgu/obsidian-dataview/blob/322217ad563defbc213f6731c9cd5a5f5a7e3638/src/data-import/common.ts#L5
+// Forbid @ since obsidian does not allow it
+
+const POTENTIAL_TAG_MATCHER = /[^+@\s,;.:!&*?'"`()\[\]{}]+/giu;
+// With hashtag and spaces before
+const POTENTIAL_FULLTAG_MATCHER = /\s+#[^+@\s,;.:!&*?'"`()\[\]{}]+/giu;
+
+/**
+ * Only take the first word
+ * @param text workflow name without tags
+ */
+export function getWorkflowNameFromRawText(text: string) {
+ const found = text.match(POTENTIAL_TAG_MATCHER)
+ return found ? found[0] : null;
+}
+
+export interface I_OdaPmProjectTask {
+
+ // 0.2.0
+ projects: OdaPmProject[];
+ addProject: (project: OdaPmProject) => void;
+ isInProject: (name: string) => boolean;
+ /**
+ * Called when no project is added. Returns the path of the markdown path.
+ */
+ getProjectPath: () => string;
+}
+
+// Unit Test
+// console.log(getWorkflowNameFromRawText("å¸¦ä½ é£ž å¸¦ä½ é£ž2 \n vads ads f \t li"))
+
+export interface I_OdaPmStep {
+ tag: string;
+ name: string;
+ toObject: () => object
+}
+
+
+export interface I_OdaPmWorkflow extends I_OdaPmProjectTask {
+ boundTask: STask;
+ name: string;
+ stepsDef: I_OdaPmStep[];
+ type: WorkflowType;
+ tag: string;
+
+ clearSteps: () => void
+ addStep: (tag: string) => void
+ includesStep: (tag: string) => boolean
+}
+
+/**
+ * Dont check.
+ */
+export function factoryTask(task: STask, type: I_OdaPmWorkflow) {
+ return new OdaPmTask(type, task)
+}
+
+
+// region StepTag Manipulate
+/**
+ * add a tag at the end of the line. the tag will be followed by a space
+ * @param text
+ * @param stepTag
+ */
+export function addTagText(text: string, stepTag: string) {
+ // With the rule that a task cannot cross multiple lines, we can safely assume that the last char is \n if there is a \n.
+ const hasTrailingEol = text.indexOf("\n") == text.length - 1
+ // We believe dataview gives the correct result. In the latter case there will be no step.tag in the original text if includes is false.
+ return `${text.trimEnd()} ${stepTag} ` + (hasTrailingEol ? "\n" : "");
+}
+
+// TODO wont remove the space before or after the tag
+export function removeTagText(text: string, stepTag: string) {
+ return text.replace(stepTag, "");
+}
+
+
+// endregion
+
+
+export function isTaskSingleLine(task: STask) {
+ Iif (!task.text) return false;
+ Iif (!task.text.includes("\n")) return true;
+ const firstOccurrence = task.text.indexOf("\n");
+ // check if there are text after the first occurrence
+ const hasTextAfterEol = task.text.length <= firstOccurrence + 1;
+
+ return hasTextAfterEol;
+}
+
+// region Project
+export function getProjectTagFromSTask(task: STask) {
+
+ for (const tag of task.tags) {
+ Iif (tag.startsWith(Tag_Prefix_Project)) {
+ return tag;
+ }
+ }
+ return null;
+}
+
+export function getProjectNameFromTag(tag: string) {
+ const name = tag.replace(Tag_Prefix_Project, "");
+ return name;
+}
+
+// - A task's path is
+// 1. If it defines a project, the project name is appended.
+// 2. If not, the task's path is the same as the file's.
+export function getProjectPathFromSTask(task: STask, leadingSlash = false) {
+ const prjTag = getProjectTagFromSTask(task);
+ if (prjTag !== null) {
+ // If defined by a task, path = `path/to/file:{project name}`.
+ return `${leadingSlash ? "/" : ""}${task.path}:${getProjectNameFromTag(prjTag)}`;
+ } else
+ return `${leadingSlash ? "/" : ""}${task.path}`;
+}
+
+// endregion
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| data-model | +
+
+ |
+ 22.95% | +56/244 | +1.56% | +1/64 | +4.76% | +3/63 | +24.13% | +56/232 | +
| utils | +
+
+ |
+ 7.01% | +8/114 | +0% | +0/17 | +0% | +0/29 | +7.4% | +8/108 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 | 2x + +2x + +2x + + +2x + + + +2x + + + + +2x + + + + + +2x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +2x + + + + + + + + + + + | import process from "process";
+import OdaPmToolPlugin from "../main";
+import {expect} from "chai";
+import {OdaPmDb} from "../data-model/odaPmDb";
+import {OdaPmProject, ProjectDefinedType, ProjectName_Unclassified} from "../data-model/OdaPmProject";
+import {OdaPmTask} from "../data-model/OdaPmTask";
+
+export function isProduction() {
+ return process.env.NODE_ENV === "production";
+}
+
+export function devLog(...args: any[]) {
+ Iif (isProduction()) return;
+ console.log(...args);
+}
+
+export function devAssert(...args: any[]) {
+ Iif (isProduction()) return;
+ console.assert(...args)
+}
+
+// Test in dev mode.
+export function assertOnPluginInit(plugin: OdaPmToolPlugin) {
+ Iif (isProduction()) return;
+ console.log("Assert start: on plugin init...");
+ console.log("Assert End: on plugin init.")
+}
+
+function expect_project(prj: OdaPmProject | undefined, projectName: string, definedType?: ProjectDefinedType) {
+ expect(prj).to.not.be.undefined;
+ Iif (prj) {
+ expect(prj.name).to.equal(projectName);
+ Iif (definedType)
+ expect(prj.hasDefinedType(definedType)).to.be.true;
+ }
+}
+
+function expectTaskAbstract(pmDb: OdaPmDb, taskSummary: string, func: (task: OdaPmTask) => void) {
+ const task = pmDb.getPmTaskBySummary(taskSummary);
+ expect(task).to.not.be.null;
+ Iif (task) {
+ func(task);
+ }
+}
+
+async function testProjectDefinition(projects: OdaPmProject[], pmDb: OdaPmDb) {
+ const ut_projects = projects.filter(k =>
+ k.name.startsWith("UT_020_1_") && (k.hasDefinedType("file") || k.hasDefinedType("folder"))
+ );
+ const correct = 4;
+ expect(ut_projects, `Front matter defined projects not matched. Prefix 'UT_020_1_'.`)
+ .to.have.lengthOf(correct);
+
+ const ut_task_projects = projects.filter(k =>
+ k.name.startsWith("UT_020_1_") && k.hasDefinedType("tag_override")
+ );
+ expect(ut_task_projects, `Task tag defined projects not matched. Prefix 'UT_020_1_'.`).to.have.lengthOf(1);
+
+ const ut_020_2_1_projects = projects.filter(k => {
+ return k.pmTasks.filter(m => m.summary.startsWith("UT_020_2_1")).length > 0
+ }); // The task starting with UT_020_2_1 is in Unclassified project.
+ expect(ut_020_2_1_projects, `PmTask with prefix 'UT_020_2_1' not matched`).to.have.lengthOf(1);
+ expect_project(ut_020_2_1_projects.first(), ProjectName_Unclassified, "tag_override");
+
+ const ut_020_2_1_projects_wf = projects.filter(k => {
+ return k.workflows.filter(m => m.name.startsWith("UT_020_2_1")).length > 0
+ }); // The workflow starting with UT_020_2_1 is in Unclassified project.
+ expect(ut_020_2_1_projects_wf, `Workflow with prefix 'UT_020_2_1' not matched`).to.have.lengthOf(1);
+ expect_project(ut_020_2_1_projects_wf.first(), ProjectName_Unclassified, "tag_override");
+
+ const ut_020_2_2_tasks = pmDb.pmTasks.filter(k => {
+ return k.summary.startsWith("UT_020_2_2")
+ })
+ expect(ut_020_2_2_tasks, `PmTask with prefix 'UT_020_2_2' not matched`).to.have.lengthOf(1);
+ const ut_020_2_2_task = ut_020_2_2_tasks.first();
+ Iif (ut_020_2_2_task) {
+ expect(ut_020_2_2_task.isInProject("UT_020_2_Project_Layer_1_folder_definition"));
+ }
+
+ const ut_020_2_2_workflows = pmDb.workflows.filter(k => {
+ return k.name.startsWith("UT_020_2_2")
+ });
+ expect(ut_020_2_2_workflows, `Workflow with prefix 'UT_020_2_2' not matched`).to.have.lengthOf(1);
+ const ut_020_2_2_wf = ut_020_2_2_workflows.first();
+ Iif (ut_020_2_2_wf) {
+ expect(ut_020_2_2_wf.isInProject("UT_020_2_Project_Layer_1_folder_definition"));
+ }
+
+
+ const ut_020_2_3_tasks = pmDb.pmTasks.filter(k => {
+ return k.summary.startsWith("UT_020_2_3")
+ })
+ expect(ut_020_2_3_tasks, `PmTask with prefix 'UT_020_2_3' not matched`).to.have.lengthOf(1);
+ const ut_020_2_3_task = ut_020_2_3_tasks.first();
+ Iif (ut_020_2_3_task) {
+ expect(ut_020_2_3_task.isInProject("UT_020_2_Project_Layer_1_file_definition"));
+ }
+
+ const ut_020_2_3_workflows = pmDb.workflows.filter(k => {
+ return k.name.startsWith("UT_020_2_3")
+ });
+ expect(ut_020_2_3_workflows, `Workflow with prefix 'UT_020_2_3' not matched`).to.have.lengthOf(1);
+ const ut_020_2_3_wf = ut_020_2_3_workflows.first();
+ Iif (ut_020_2_3_wf) {
+ expect(ut_020_2_3_wf.isInProject("UT_020_2_Project_Layer_1_file_definition"));
+ }
+
+
+ const ut_020_2_4_tasks = pmDb.pmTasks.filter(k => {
+ return k.summary.startsWith("UT_020_2_4")
+ })
+ expect(ut_020_2_4_tasks, `PmTask with prefix 'UT_020_2_4' not matched`).to.have.lengthOf(1);
+ const ut_020_2_4_task = ut_020_2_4_tasks.first();
+ Iif (ut_020_2_4_task) {
+ expect(ut_020_2_4_task.isInProject("UT_020_2_Project_Layer_1_task_definition"));
+ }
+
+ const ut_020_2_4_workflows = pmDb.workflows.filter(k => {
+ return k.name.startsWith("UT_020_2_4")
+ });
+ expect(ut_020_2_4_workflows, `Workflow with prefix 'UT_020_2_4' not matched`).to.have.lengthOf(1);
+ const ut_020_2_4_wf = ut_020_2_4_workflows.first();
+ Iif (ut_020_2_4_wf) {
+ expect(ut_020_2_4_wf.isInProject("UT_020_2_Project_Layer_1_task_definition"));
+ }
+}
+
+async function testTaskProjectLink(pmDb: OdaPmDb) {
+
+ function expectTaskInProject(taskName: string, projectName: string) {
+ expectTaskAbstract(pmDb, taskName, (task) => {
+ expect(task.isInProject(projectName), `Task ${taskName} not in project ${projectName}. Task Path: ${task.getProjectPath()}. Task Project: ${JSON.stringify(task.getProjectNames())}`).true;
+ })
+ }
+
+ expectTaskInProject("UT_020_3_2_Unclassified", ProjectName_Unclassified);
+ expectTaskInProject("UT_020_3_2_Prj4", "UT_020_3_Prj4");
+ expectTaskInProject("UT_020_3_2_file1_Prj1", "UT_020_3_Prj1")
+ expectTaskInProject("UT_020_3_2_file2_Prj2", "UT_020_3_Prj2")
+ expectTaskInProject("UT_020_3_2_file3_Prj1", "UT_020_3_Prj1")
+ expectTaskInProject("UT_020_3_2_file3_Prj3", "UT_020_3_Prj3")
+ expectTaskInProject("UT_020_3_2_file4_Prj3", "UT_020_3_Prj3")
+ devLog("Test PASSED: Task Project Link.")
+}
+
+async function testGetTaskProjectPath(pmDb: OdaPmDb) {
+ function expectTaskPath(taskName: string, path: string) {
+ expectTaskAbstract(pmDb, taskName, (task) => {
+ expect(task.getProjectPath(), `Task ${taskName} 's path not matched.`)
+ .equal(path);
+ })
+ }
+
+ expectTaskPath("UT_020_3_2_Unclassified", "/UT_020_3 layer 0 file_any.md");
+ expectTaskPath("UT_020_3_2_Prj4", "/UT_020_3 layer 0 file_any.md:UT_020_3_Prj4");
+ expectTaskPath("UT_020_3_2_file1_Prj1", "/UT_020_3 project Folder/UT_020_3 projectroot Prj1.md")
+ expectTaskPath("UT_020_3_2_file2_Prj2", "/UT_020_3 project Folder/UT_020_3 file2 Prj2.md")
+ expectTaskPath("UT_020_3_2_file3_Prj1", "/UT_020_3 project Folder/UT_020_3 file3 Prj1.md")
+ expectTaskPath("UT_020_3_2_file3_Prj3", "/UT_020_3 project Folder/UT_020_3 file3 Prj1.md:UT_020_3_Prj3")
+ expectTaskPath("UT_020_3_2_file4_Prj3", "/UT_020_3 project Folder/UT_020_3 file4 Prj3.md")
+ devLog("Test PASSED: Get Task Project Path.")
+}
+
+async function test_UT_020_3(pmDb: OdaPmDb) {
+ // UT_020_3
+ // Sanity check
+ const ut_020_3_tasks = pmDb.pmTasks.filter(k => {
+ return k.summary.startsWith("UT_020_3")
+ });
+ expect(ut_020_3_tasks, `PmTask with prefix 'UT_020_3' not matched`).to.have.lengthOf(7);
+ testGetTaskProjectPath(pmDb);
+ testTaskProjectLink(pmDb);
+}
+
+// make this async so the failing tests won't block the plugin and database initialization process.
+export async function assert(pmDb: OdaPmDb) {
+ devLog("Assert start: on db refreshed...")
+ const projects = pmDb.pmProjects;
+
+ const projectIds = projects.map(k => k.internalKey).unique();
+ expect(projectIds, `Project ids are not unique.`).to.have.lengthOf(projects.length);
+ test_UT_020_3(pmDb);
+ testProjectDefinition(projects, pmDb);
+
+ devLog("Assert end: on db refreshed...")
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| env-util.ts | +
+
+ |
+ 7.01% | +8/114 | +0% | +0/17 | +0% | +0/29 | +7.4% | +8/108 | +