imdone-core 2.0.0 → 2.0.1

package/lib/adapters/parsers/content-transformer.js

@@ -0,0 +1,116 @@
+import { Eta } from "eta"
+import uniqid from 'uniqid';
+
+function removeDisplayComments(description) {
+  return description.replace(/<!--\s*\[([\s\S]*?)\]\s*-->/g, '$1');
+}
+
+function escapeCodeBlocks(content) {
+  const codeBlockRegex = /(```[\s\S]*?```|`[^`]*`)/g;
+  let codeBlocks = [];
+
+  // Replace code blocks with unique keys
+  content = content.replace(codeBlockRegex, (match) => {
+    const key = `__CODE_BLOCK_${codeBlocks.length}__`;
+    codeBlocks.push(match); // Maintain order
+    return key;
+  });
+
+  return { content, codeBlocks };
+}
+
+function restoreCodeBlocks(content, codeBlocks) {
+  // Restore code blocks in order using stored array
+  codeBlocks.forEach((code, index) => {
+    content = content.replace(`__CODE_BLOCK_${index}__`, code);
+  });
+  return content;
+}
+
+/**
+ * Interpolates the content with the provided data.
+ * @param {string} content - The content to interpolate.
+ * @param {object} data - The data to use for interpolation.
+ * @param {object} opts - The options for interpolation.
+ * @returns {object} - The interpolated content, whether there was interpolation, and error tokens.
+ */
+export function interpolate(content, data, opts = { tags: ['${', '}'] }) {
+  const errorTokens = {};
+  const { tags } = opts;
+  // /(?<![`\\])\${([\s\S]+?)}/g
+  const regex = new RegExp(`(?<![\`\\\\])\\${tags[0]}([\\s\\S]+?)${tags[1]}`, 'g');
+  let hasInterpolation = false;
+
+  content = content.replace(regex, (match, p1) => {
+    try {
+      const eta = new Eta({ tags, useWith: true, autoEscape: false });
+      const [startTag, endTag] = opts.tags;
+      const template = `${startTag}= ${p1} ${endTag}`;
+      const result = eta.renderString(template, data);
+      if (result !== match) {
+        hasInterpolation = true;
+      }
+      return result || '';
+    } catch (e) {
+      const token = `__ERROR_TOKEN_${uniqid()}__`;
+      errorTokens[token] = match;
+      return token || '';
+    }
+  });
+
+  return { content, hasInterpolation, errorTokens };
+}
+
+export function encodeMarkdownLinks(content) {
+  return content.replace(/(?<!!)\[(.*?)\]\((.*?)( ".*?")?\)/g, (match, p1, p2, p3) => {
+    // URI encode file links
+    const title = p3 || '';
+    const encodedUrl = p2.replace(/\s/g, '%20').replace(/\)/g, '%29').replace(/\(/g, '%28');
+    const link = `[${p1}](${encodedUrl}${title})`;
+
+    // If there is more than one space in the URL, assume there's no title
+    if ((p2.match(/\s/g) || []).length > 1) {
+      return `[${p1}](${encodedUrl})`;
+    }
+
+    return link.replace(/%20(".*?"\))$/, ' $1');
+  });
+}
+
+export function format(content, data, mustache) {
+  const errorTokens = {};
+
+  if (mustache) content = removeDisplayComments(content);
+
+  // Escape code blocks before processing interpolation
+  const { content: escapedContent, codeBlocks } = escapeCodeBlocks(content);
+
+  let result = escapedContent;
+  let hasInterpolation = true;
+
+  while (hasInterpolation) {
+    const interpolationResult = interpolate(result, data, { tags: ['${', '}'] });
+    result = interpolationResult.content;
+    hasInterpolation = interpolationResult.hasInterpolation;
+    Object.assign(errorTokens, interpolationResult.errorTokens);
+  }
+
+  if (mustache) {
+    hasInterpolation = true;
+    while (hasInterpolation) {
+      const interpolationResult = interpolate(result, data, { tags: ['{{', '}}'] });
+      result = interpolationResult.content;
+      hasInterpolation = interpolationResult.hasInterpolation;
+      Object.assign(errorTokens, interpolationResult.errorTokens);
+    }
+  }
+
+  result = restoreCodeBlocks(result, codeBlocks);
+
+  // Restore error tokens
+  Object.keys(errorTokens).forEach(token => {
+    result = result.replace(new RegExp(token, 'g'), errorTokens[token]);
+  });
+
+  return result;
+}

package/lib/adapters/parsers/file/LocalFileParserFactory.js

@@ -0,0 +1,36 @@
+import { createReadStream } from 'node:fs'
+import { ReadStreamMarkdownParser } from './ReadStreamMarkdownParser.js'
+import path from 'node:path'
+import { languages } from '../../../languages.js'
+import { ReadStreamCodeParser } from './ReadStreamCodeParser.js'
+
+
+export function getLang(config, filePath) {
+  const languages = getLanguages(config)
+  var lang = languages[path.extname(filePath)]
+  return lang || { name: 'text', symbol: '' }
+}
+
+export function getLanguages(config) {
+  const configLanguages = config.languages || {}
+  return { ...languages, ...configLanguages }
+}
+
+export async function getFileParser (filePath, config, readStream) {
+  if (!readStream) {
+    readStream = createReadStream(filePath)
+  }
+  const lang = getLang(config, filePath)
+  if (lang.name === 'text') {
+    return new ReadStreamMarkdownParser(readStream, config)
+  } else {
+    const parser = new ReadStreamCodeParser(
+      readStream,
+      filePath,
+      lang,
+      config.lists
+    )
+    await parser.init()
+    return parser
+  }
+}

package/lib/adapters/parsers/file/ReadStreamCodeParser.js

@@ -0,0 +1,126 @@
+import path from 'node:path'
+import { ReadStreamTaskParser } from './ReadStreamTaskParser.js'
+import { CodeStyleTaskParser } from '../task/CodeStyleTaskParser.js'
+import { languages } from '../../../languages.js'
+import extractComments from 'multilang-extract-comments'
+import eol from 'eol'
+import { Readable } from 'node:stream'
+
+// TODO Move to readstream parsing for code to improve performance
+// <!--
+// #important
+// #imdone-1.55.0
+// order:-205
+// -->
+export class ReadStreamCodeParser extends ReadStreamTaskParser {
+  constructor(readStream, filePath, lang, lists) {
+    super(readStream)
+    this.lists = lists
+    this.filePath = filePath
+    this.lang = lang
+    this.taskParsers = [new CodeStyleTaskParser()]
+  }
+
+  async init() {
+    const code = await streamToString(this.readStream)
+    // TODO Getting tokens from lists should be done higher up in the controller
+    // <!--
+    // order:-10
+    // -->
+    const tokens = this.lists.filter(list => !list.filter).map(list => list.name)
+    this.cards = this.parseCards(code, tokens)
+  }
+
+  async readTask() {
+    return this.cards.shift()
+  }
+
+  parseCards(code, tokens = ['TODO']) {
+    const comments = this.parseComments(code);
+    const cards = [];
+  
+    Object.keys(comments).forEach((comment) => {
+      const { begin, end, content } = comments[comment];
+      const line = begin;
+      const lastLine = end; // TODO lastLine should not be - 1
+                            // <!--
+                            // order:-140
+                            // -->
+      const lines = content.split('\n');
+  
+      // Check if the comment contains "TODO"
+      lines.forEach(codeLine => {
+        if (tokens.find((token) => codeLine.includes(token))) {
+          // Get all lines from start to end
+          
+          cards.push({
+            content,
+            line,
+            lastLine,
+          });
+        }
+      });
+    });
+    return cards;
+  }
+  
+  parseComments(code) {
+    const options = getLanguageOptions(this.filePath);
+    const comments = extractComments(code, options);
+    return comments;
+  }
+  
+}
+
+
+function getLanguageOptions(filePath) {
+  const extension = path.extname(filePath)
+  const language = languages[extension]
+  
+  
+  const {
+      name,
+      symbol,
+      block,
+    } = language || 
+    { 
+      name: 'text', 
+      symbol: '', 
+      block: {
+        start: undefined,
+        end: undefined,
+        ignore: undefined,
+      }
+    };
+  // Use lang to get comment patterns
+
+  const {
+    start,
+    ignore: middle,
+    end
+  } = block || {};
+  
+  return language && {
+    pattern: {
+      name,
+      nameMatchers: extension && [extension] || [],
+      singleLineComment: symbol && [{ start: symbol }] || [],
+      multiLineComment: start && end && [{ start, middle, end }] || [],
+    },
+  };
+}
+
+async function streamToString(stream) {
+  const chunks = []
+
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk))
+  }
+
+  return Buffer.concat(chunks).toString('utf-8')
+}
+
+function stringToStream(string) {
+  const lines = eol.split(string).map((line) => line + String(eol.auto))
+  return Readable.from(lines)
+}

package/lib/adapters/parsers/file/ReadStreamMarkdownParser.js

@@ -0,0 +1,17 @@
+import { ReadStreamTaskParser } from './ReadStreamTaskParser.js'
+import { HashStyleTaskParser } from '../task/HashStyleTaskParser.js'
+import { MarkdownStyleTaskParser } from '../task/MarkdownStyleTaskParser.js'
+// const CheckStyleTaskParser = require('../task/CheckStyleTaskParser')
+
+export class ReadStreamMarkdownParser extends ReadStreamTaskParser {
+  constructor(readStream, config) {
+    super(readStream, config)
+    this.taskParsers = [
+      new HashStyleTaskParser(config),
+      new MarkdownStyleTaskParser(config),
+    ]
+    // if (config.isAddCheckBoxTasks()) {
+    //   this.taskParsers.push(new CheckStyleTaskParser())
+    // }
+  }
+}

package/lib/adapters/parsers/file/ReadStreamTaskParser.js

@@ -0,0 +1,106 @@
+import * as ReadLine from 'node:readline/promises';
+import { logger } from '../../logger.js';
+
+const blankLinesToEndTask = 2
+
+export class ReadStreamTaskParser {
+  constructor(readStream) {
+    this.readStream = readStream
+    this.task = null
+    this.line = null
+    this.taskParsers = []
+    this.lineNo = 0
+    this.blankLines = 0
+    this.readInterface = ReadLine.createInterface({
+      input: this.readStream,
+      crlfDelay: Infinity,
+      console: false,
+    })
+  }
+
+  async readTask() {
+    let taskOrStreamDone = false
+    this.task = this.nextTask || null
+    this.blankLines = 0
+
+    try {
+      while (!taskOrStreamDone) {
+        this.line = await this.readLine()
+        let { value, done } = this.line
+        if (this.line && !done) {
+          this.lineNo++
+          const endOfTask = this.isEndOfTask(value)
+          if (this.task && endOfTask) {
+            taskOrStreamDone = true
+          } else if (this.task) {
+            this.addLineToTask(value)
+          } else {
+            this.task = this.getTaskFromLine(value)
+          }
+        } else {
+          taskOrStreamDone = true
+        }
+      }
+    } catch (error) {
+      logger.log('Error reading line')
+      throw error
+    }
+
+    this.trimLinesToEndTask()
+    return this.task
+  }
+
+  async readLine() {
+    return this.readInterface[Symbol.asyncIterator]().next()
+  }
+
+  isEndOfTask(line) {
+    if (line.trim() === '') {
+      this.blankLines++
+    } else {
+      this.blankLines = 0
+    }
+
+    this.nextTask = this.getTaskFromLine(line)
+    
+    if (this.blankLines > blankLinesToEndTask - 1) {
+      this.nextTask = undefined
+      return true
+    }
+
+    if (this.nextTask) {
+      return true
+    }
+
+    return false
+  }
+
+  getTaskFromLine(line) {
+    let task
+    this.taskParsers.find((taskParser) => {
+      task = taskParser.parseLine(line, this.lineNo, this.task)
+      return task
+    })
+    return task
+  }
+
+  addLineToTask(line) {
+    this.task.description.push(line)
+    this.task.lastLine = this.lineNo
+  }
+
+  trimLinesToEndTask() {
+    if (!this.task) return
+
+    // Remove the empty strings from the end of the task description
+    while (this.task.description[this.task.description.length - 1] === '') {
+      this.task.description.pop()
+    }
+    this.task.lastLine = this.task.line + this.task.description.length
+  }
+
+  close() {
+    this.readInterface.close()
+    if (this.readStream.close) this.readStream.close()
+  }
+}

package/lib/adapters/parsers/file/index.js

@@ -0,0 +1,4 @@
+export * from './LocalFileParserFactory.js';
+export * from './ReadStreamCodeParser.js';
+export * from './ReadStreamMarkdownParser.js';
+export * from './ReadStreamTaskParser.js';

package/lib/adapters/parsers/function-parser.js

@@ -0,0 +1,25 @@
+export function getFunctionSignature(fn) {
+  if (typeof fn !== "function") {
+    throw new TypeError("Expected a function");
+  }
+
+  const fnString = fn.toString().trim();
+  let name = fn.name || "anonymous";
+  let params = "";
+
+  // Match function parameters
+  const paramMatch = fnString.match(/\(([^)]*)\)/);
+  if (paramMatch) {
+    params = paramMatch[1].trim();
+  } else {
+    // Handle arrow functions without parentheses
+    const arrowMatch = fnString.match(/^(?:\S+\s+)?(\w+)?\s*=?\s*(?:async\s*)?\(?([^)=]*)\)?\s*=>/);
+    if (arrowMatch) {
+      name = name || arrowMatch[1] || "anonymous";
+      params = arrowMatch[2].trim();
+    }
+  }
+
+  return `${name}(${params})`;
+}
+

package/lib/adapters/parsers/index.js

@@ -0,0 +1,5 @@
+export * from './DateLanguageParser.js';
+export * from './content-transformer.js';
+export * from './function-parser.js';
+export * as file from './file/index.js';
+export * as task from './task/index.js';