imdone-core 1.54.10 → 2.0.0

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

@@ -1,111 +0,0 @@
-const template = require('lodash.template')
-const uniqid = require('uniqid');
-
-module.exports = {
-  format,
-  encodeMarkdownLinks
-}
-
-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.
- */
-function interpolate(content, data, opts) {
-  const errorTokens = {};
-  let hasInterpolation = false;
-
-  content = content.replace(opts.interpolate, (match, p1) => {
-    try {
-      const result = template(match, opts)(data);
-      if (result !== match) {
-        hasInterpolation = true;
-      }
-      return result;
-    } catch (e) {
-      const token = `__ERROR_TOKEN_${uniqid()}__`;
-      errorTokens[token] = match;
-      return token;
-    }
-  });
-
-  return { content, hasInterpolation, errorTokens };
-}
-
-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})`;
-    return link.replace(/%20(".*?"\))$/, ' $1');
-  });
-}
-
-function format(content, data, mustache) {
-  const opts = { interpolate: /(?<![`\\])\${([\s\S]+?)}/g };
-  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, opts);
-    result = interpolationResult.content;
-    hasInterpolation = interpolationResult.hasInterpolation;
-    Object.assign(errorTokens, interpolationResult.errorTokens);
-  }
-
-  if (mustache) {
-    const mustacheOpts = { interpolate: /(?<!`){{([\s\S]+?)}}/g };
-    hasInterpolation = true;
-    while (hasInterpolation) {
-      const interpolationResult = interpolate(result, data, mustacheOpts);
-      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

@@ -1,37 +0,0 @@
-const { createReadStream } = require('fs')
-const ReadStreamMarkdownParser = require('./ReadStreamMarkdownParser')
-const path = require('path')
-const languages = require('../../../languages')
-const ReadStreamCodeParser = require('./ReadStreamCodeParser')
-
-
-function getLang(config, filePath) {
-  const languages = getLanguages(config)
-  var lang = languages[path.extname(filePath)]
-  return lang || { name: 'text', symbol: '' }
-}
-
-function getLanguages(config) {
-  const configLanguages = config.languages || {}
-  return { ...languages, ...configLanguages }
-}
-
-module.exports.getLang = getLang
-module.exports.getFileParser = 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

@@ -1,126 +0,0 @@
-const path = require('path')
-const ReadStreamTaskParser = require('./ReadStreamTaskParser')
-const CodeStyleTaskParser = require('../task/CodeStyleTaskParser')
-const languages = require('../../../languages')
-const extractComments = require('multilang-extract-comments')
-const eol = require('eol')
-const { Readable } = require('stream')
-
-// TODO Move to readstream parsing for code to improve performance
-// <!--
-// #important
-// #imdone-1.55.0
-// order:-205
-// -->
-module.exports = 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

@@ -1,17 +0,0 @@
-const ReadStreamTaskParser = require('./ReadStreamTaskParser')
-const HashStyleTaskParser = require('../task/HashStyleTaskParser')
-const MarkdownStyleTaskParser = require('../task/MarkdownStyleTaskParser')
-// const CheckStyleTaskParser = require('../task/CheckStyleTaskParser')
-
-module.exports = 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

@@ -1,104 +0,0 @@
-const ReadLine = require('readline')
-const blankLinesToEndTask = 2
-
-module.exports = 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) {
-      console.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/function-parser.js

@@ -1,29 +0,0 @@
-module.exports = {
-  getFunctionSignature
-};
-
-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})`;
-}
-