imdone-core 1.54.9 → 2.0.0

package/lib/adapters/parsers/task/CardContentParser.js

@@ -1,376 +0,0 @@
-const eol = require('eol')
-const XRegExp = require('xregexp')
-
-const FILE_TYPES = {
-  MARKDOWN: 'markdown',
-  CODE: 'code',
-}
-const TASK_TYPES = {
-  CODE: 'CODE',
-  HASHTAG: 'HASHTAG',
-  MARKDOWN: 'MARKDOWN',
-}
-
-const DEFAULT_TOKEN_PREFIX = '#'
-const START_TAG = '<card>'
-const END_TAG = '</card>'
-const CODE_STYLE_PATTERN = '([A-Z]+[A-Z-_]+?)((:)(-?[\\d.]+(?:e-?\\d+)?)?)?[ \\t]+(.+)$'
-const LIST_NAME_PATTERN = '[\\p{L}0-9-_]{2,}' // [a-zA-Z-_]+?
-const LINK_STYLE_REGEX = new XRegExp(
-  `(\\[.*\\]\\s?)?(\\[(.+)\\]\\(#(${LIST_NAME_PATTERN})(:)(-?[\\d.]+(?:e-?\\d+)?)?\\))`,
-  'gm'
-)
-
-const CHECK_REGEX = /^(\s*- )\[([x ])\]/
-
-function getHashStyleRegex(tokenPrefix = DEFAULT_TOKEN_PREFIX, orderMeta = false) {
-  return orderMeta ?
-    new XRegExp(
-      `${tokenPrefix}(${LIST_NAME_PATTERN})[ \\t]+(.+)$`, 'gm'
-    ) :
-    new XRegExp(
-      `${tokenPrefix}(${LIST_NAME_PATTERN})(:(-?[\\d.]+(?:e-?\\d+)?)?)?[ \\t]+(.+)$`,
-      'gm'
-    )
-}
-
-function getCheckedData(content) {
-  const taskRegex = new RegExp(CHECK_REGEX)
-  const result = taskRegex.exec(content)
-  return result
-    ? {
-        pad: result[1].length,
-        checked: result[2].trim() !== '',
-      }
-    : null
-}
-
-function getContentLines(content) {
-  let foundContent = false
-  return eol.split(content).filter((line) => {
-    const hasContent = line.trim()
-    if (!foundContent && hasContent) foundContent = true
-    return foundContent || hasContent
-  })
-}
-
-function isCustomCardTerminator(config, line) {
-  return config.customCardTerminator 
-    && config.customCardTerminator.trim() 
-    && line 
-    && line.trim() === config.customCardTerminator
-}
-
-function isCheckBoxTask (config, line, beforeText) {
-  if (!config.isAddCheckBoxTasks()) return
-
-  const beforeTextCheckData = getCheckedData(beforeText)
-  if (!beforeTextCheckData) return
-
-  const lineCheckData = getCheckedData(line)
-  if (!lineCheckData) return
-
-  return lineCheckData.pad <= beforeTextCheckData.pad
-}
-
-function hasTaskInText(config, text, isCodeFile) {
-  const hashStyleRegex = new XRegExp(getHashStyleRegex(config.tokenPrefix));
-  const linkStyleRegex = new XRegExp(LINK_STYLE_REGEX);
-
-  const inlineCodeRe = /`[^`]*`/g;
-
-  // Function to check if a match is within inline code
-  function isWithinInlineCode(index) {
-    let match;
-    while ((match = inlineCodeRe.exec(text)) !== null) {
-      const isInCode = index >= match.index && index < match.index + match[0].length
-      if (isInCode) return true;
-    }
-    return false;
-  }
-
-  // Check for code style tasks
-  if (isCodeFile && hasCodeStyleTask(config, text)) {
-    return true;
-  }
-
-  // Check for hash style tasks
-  let result;
-  if ((result = hashStyleRegex.exec(text)) !== null && !isWithinInlineCode(result.index)) {
-    return config.lists.find((list) => text.includes(`${config.tokenPrefix}${list.name}`));
-  }
-
-  // Check for link style tasks
-  if ((result = linkStyleRegex.exec(text)) !== null && !isWithinInlineCode(result.index)) {
-    return config.lists.find((list) => text.includes(`${config.tokenPrefix}${list.name}`));
-  }
-
-  return false;
-}
-
-function isBeforeTextMarkdownList(beforeText) {
-  return /^\s*(\*|-|- \[[x| ]\]|\d+\.|[a-zA-Z]\.)\s$/.test(beforeText)
-}
-
-function isMarkdownListItem(line) {
-  return /^\s*(\*|-|- \[[x| ]\]|\d+\.|[a-zA-Z]\.)\s/.test(line)
-}
-
-function padDescription(description = [], beforeText = '') {
-  if (!isBeforeTextMarkdownList(beforeText)) return description
-  return description.map((line) => {
-    return line.padStart(line.length + beforeText.length)
-  })
-}
-
-function isLineOutsideMarkdownList(line, beforeText) {
-  return isBeforeTextMarkdownList(beforeText) &&
-    isMarkdownListItem(line) &&
-    line.search(/\S/) <= beforeText.search(/\S/)
-}
-
-function hasCodeStyleTask(config, text) {
-  const codeStylePatternRe = new RegExp(CODE_STYLE_PATTERN);
-  let result = codeStylePatternRe.exec(text);
-
-  if (!result) return false;
-
-  // Check if the match is within inline code
-  const inlineCodeRe = /`[^`]*`/g;
-  let match;
-  while ((match = inlineCodeRe.exec(text)) !== null) {
-    if (result.index >= match.index && result.index < match.index + match[0].length) {
-      return false;
-    }
-  }
-
-  return config.includeList(result[1]);
-}
-
-function getCardTagsTaskContent ({
-  content,
-  fileType
-}) {
-  const isCodeFile = fileType === FILE_TYPES.CODE
-  if (isCodeFile) return
-  
-  const isMarkDownFile = fileType === FILE_TYPES.MARKDOWN
-  let lines = getContentLines(content)
-  const hasCardStartTag =
-    isMarkDownFile && lines.length > 1 && lines[1].trim() === START_TAG
-  if (!hasCardStartTag) return
-
-  let openBlockCommentTokens = 0
-  let closeBlockCommentTokens = 0
-  let hasCardEndTag = false
-  const rawTaskContentLines = []
-  const taskContentLines = []
-  for (let i = 1; i < lines.length; i++) {
-    let line = lines[i]
-    // Check for matching block comments in markdown files
-    if (isMarkDownFile && line.trim().indexOf('<!--') > -1)
-      openBlockCommentTokens++
-    if (isMarkDownFile && line.trim().indexOf('-->') > -1)
-      closeBlockCommentTokens++
-
-    rawTaskContentLines.push(line)
-
-    if (line.trim() === START_TAG) continue
-    if (line.trim() === END_TAG) {
-      hasCardEndTag = true
-      break
-    }
-    taskContentLines.push(line)
-  }
-
-  // Remove extra block comment tokens
-  if (
-    isMarkDownFile &&
-    rawTaskContentLines.length &&
-    rawTaskContentLines[rawTaskContentLines.length - 1].trim() === '-->' &&
-    openBlockCommentTokens !== closeBlockCommentTokens
-  )
-    rawTaskContentLines.pop()
-
-  const isWrappedWithCardTag = hasCardStartTag && hasCardEndTag
-
-  return {
-    rawTaskContentLines,
-    taskContentLines,
-    isWrappedWithCardTag,
-  }
-}
-
-// This finds the end of task
-function getCodeFileTaskContent ({
-  config,
-  content,
-  inBlockComment,
-  fileType,
-  lang
-}) {
-  const isCodeFile = fileType === FILE_TYPES.CODE
-  if (!isCodeFile) return
-
-  const rawTaskContentLines = []
-  let lines = getContentLines(content)
-  for (let i = 1; i < lines.length; i++) {
-    let line = lines[i]
-    // Another task ends a task
-    if (hasTaskInText(config, line, isCodeFile)) break
-    if (
-      !inBlockComment &&
-      (line.indexOf(lang.symbol) < 0 ||
-      line.trim().indexOf(lang.symbol) > 0 ||
-      line.trim() === lang.symbol)
-    )
-      break
-    if (lang.block && line.trim() === lang.block.end)
-      break
-    if (lang.block && line.trim() === lang.block.ignore)
-      break
-    if (line && lang && lang.block) line = line.replace(lang.block.end, '')
-    
-    rawTaskContentLines.push(line)
-  }
-  return {
-    rawTaskContentLines,
-    taskContentLines: rawTaskContentLines,
-  }
-}
-
-function getTextFileTaskContent ({
-  config,
-  content,
-  beforeText,
-  fileType,
-}) {
-  const isCodeFile = fileType === FILE_TYPES.CODE
-  if (isCodeFile) return
-
-  let lines = getContentLines(content)
-  const hasCardStartTag = lines.length > 1 && lines[1].trim() === START_TAG
-  if (hasCardStartTag) return
-
-  const isMarkDownFile = fileType === FILE_TYPES.MARKDOWN
-  const isTaskInList = isMarkDownFile && isBeforeTextMarkdownList(beforeText)
-  let openBlockCommentTokens = 0
-  let closeBlockCommentTokens = 0
-  let lastLineBlank = false
-  let endsWithDoubleBlank = false
-  let trailingBlankLines = 0
-  const rawTaskContentLines = []
-  const taskContentLines = []
-
-  let inCodeBlock = false
-
-  for (let i = 1; i < lines.length; i++) {
-    let line = lines[i]
-
-    // Check for markdown code blocks
-    if (isMarkDownFile && line.trim().startsWith('```')) {
-      inCodeBlock = !inCodeBlock
-    }
-
-    // Only break if the task is not in a markdown code block or code span
-    if (!inCodeBlock && hasTaskInText(config, line)) break
-    if (isCheckBoxTask(config, line, beforeText)) break
-    if (isTaskInList && isLineOutsideMarkdownList(line, beforeText)) break
-    if (isCustomCardTerminator(config, line)) break
-    
-    rawTaskContentLines.push(line)
-    taskContentLines.push(`${line}`)
-
-    // Check for matching block comments in markdown files
-    if (isMarkDownFile && line.trim().indexOf('<!--') > -1)
-      openBlockCommentTokens++
-    if (isMarkDownFile && line.trim().indexOf('-->') > -1)
-      closeBlockCommentTokens++  
-
-    const thisLineBlank = line.trim() === ''
-
-    if (thisLineBlank && lastLineBlank) {
-      endsWithDoubleBlank = true
-      break
-    }
-
-    lastLineBlank = thisLineBlank  
-  }
-
-  if (endsWithDoubleBlank) trailingBlankLines = 2
-  else if (lastLineBlank) trailingBlankLines = 1
-
-  // Remove extra block comment tokens
-  if (
-    isMarkDownFile &&
-    rawTaskContentLines.length &&
-    rawTaskContentLines[rawTaskContentLines.length - 1].trim() === '-->' &&
-    openBlockCommentTokens !== closeBlockCommentTokens
-  ) {
-    rawTaskContentLines.pop()
-    taskContentLines.pop()
-  }
-
-  return {
-    rawTaskContentLines,
-    taskContentLines: trailingBlankLines 
-      ? taskContentLines.slice(0, -trailingBlankLines)
-      : taskContentLines,
-    trailingBlankLines,
-  }
-}
-
-function getTaskContent ({
-  config,
-  content,
-  inBlockComment,
-  beforeText,
-  fileType,
-  lang  
-}) {
-  return getCardTagsTaskContent({ content, fileType }) ||
-    getCodeFileTaskContent({ config, content, inBlockComment, fileType, lang }) ||
-    getTextFileTaskContent({ config, content, beforeText, fileType })
-}
-
-function getRawTask ({
-  tokenPrefix = DEFAULT_TOKEN_PREFIX,
-  orderMeta = true,
-  beforeText = '',
-  hasColon = false,
-  list,
-  order = '',
-  text,
-  type = TASK_TYPES.HASHTAG
-}) {
-  if (type === TASK_TYPES.MARKDOWN) {
-    return `${beforeText || ''}[${text}](${tokenPrefix}${list}:${
-      orderMeta ? '' : order
-    })`
-  } else {
-    const colon = hasColon || (isNumber(order) && !orderMeta) ? ':' : '';
-    return `${beforeText || ''}${tokenPrefix}${list}${colon}${
-      orderMeta ? '' : order
-    } ${text}`  
-  } 
-}
-
-function isNumber (value) {
-  return !isNaN(parseFloat(value)) && isFinite(value)
-}
-
-module.exports = {
-  FILE_TYPES,
-  TASK_TYPES,
-  getTaskContent,
-  getRawTask,
-  isBeforeTextMarkdownList,
-  padDescription,
-  getCheckedData,
-  hasTaskInText,
-  isNumber,
-  getHashStyleRegex,
-  CHECK_REGEX,
-  LIST_NAME_PATTERN,
-  LINK_STYLE_REGEX
-}

package/lib/adapters/parsers/task/CheckStyleTaskParser.js

@@ -1,28 +0,0 @@
-const TaskParser = require('./TaskParser')
-
-module.exports = class CheckStyleTaskParser extends TaskParser {
-  constructor() {
-    super()
-  }
-
-  get pattern() {
-    return /^(\s*- \[([x ])\]\s)(.+$)/gm
-  }
-
-  parse(lineContent, line, matchResult, task) {
-    let [match, beforeText, checked, text] = matchResult
-    if (
-      (task && !task.beforeText) ||
-      (task && task.beforeText.length !== beforeText.length)
-    )
-      return
-    checked = checked.trim() === 'x'
-    return {
-      beforeText,
-      text,
-      line,
-      checked,
-      type: this.config.getNewCardSyntax(),
-    }
-  }
-}

package/lib/adapters/parsers/task/CodeStyleTaskParser.js

@@ -1,24 +0,0 @@
-const TaskParser = require('./TaskParser')
-
-module.exports = class CodeStyleTaskParser extends TaskParser {
-  constructor(config) {
-    super('CODE', config)
-  }
-
-  get pattern() {
-    return /^(.*?[ #]?)([a-zA-Z-_]+?)(:)(-?[\d.]+(?:e-?\d+)?)?[ \t]+(.+)$/gm
-  }
-
-  parse(lineContent, line, matchResult) {
-    const [match, beforeText, list, colon, order, text] = matchResult
-    return {
-      beforeText,
-      text,
-      order,
-      list,
-      line,
-      colon,
-      type: this.type,
-    }
-  }
-}

package/lib/adapters/parsers/task/HashStyleTaskParser.js

@@ -1,27 +0,0 @@
-const TaskParser = require('./TaskParser')
-const { getHashStyleRegex } = require('./CardContentParser')
-
-module.exports = class HashStyleTaskParser extends TaskParser {
-  constructor(config) {
-    super('HASHTAG', config)
-  }
-
-  get pattern() {
-    const config = this.config
-    return getHashStyleRegex(config.tokenPrefix, config.orderMeta)
-  }
-
-  parse(lineContent, line, matchResult) {
-    const [rawTask, list, orderGroup, order, text] = matchResult
-
-    return {
-      // beforeText,
-      text,
-      order,
-      list,
-      line,
-      colon: orderGroup && orderGroup.startsWith(':'),
-      type: this.type,
-    }
-  }
-}

package/lib/adapters/parsers/task/MarkdownStyleTaskParser.js

@@ -1,24 +0,0 @@
-const TaskParser = require('./TaskParser')
-
-module.exports = class MarkdownStyleTaskParser extends TaskParser {
-  constructor(config) {
-    super('MARKDOWN', config)
-  }
-
-  get pattern() {
-    return /^(.*)(\[(.+?)\]\(#([a-zA-Z-_]+?)(:)(-?[\d.]+(?:e-?\d+)?)?\))/gm
-  }
-
-  parse(lineContent, line, matchResult) {
-    const [match, beforeText, rawTask, text, list, colon, order] = matchResult
-    return {
-      beforeText,
-      text,
-      order,
-      list,
-      line,
-      colon,
-      type: this.type,
-    }
-  }
-}

package/lib/adapters/parsers/task/TaskParser.js

@@ -1,38 +0,0 @@
-
-class Task {
-  constructor({ beforeText, text, list, line, order, checked, colon, type }) {
-    this.contentLength = 0
-    this.description = []
-    this.beforeText = beforeText
-    this.text = text
-    this.list = list
-    this.line = line
-    this.order = order
-    this.checked = checked
-    this.colon = colon
-    this.type = type
-  }
-}
-
-module.exports = class TaskParser {
-  constructor(type, config) {
-    this.config = config
-    this.type = type
-  }
-
-  get pattern() {
-    throw new Error('Unimplemented')
-  }
-
-  parseLine(lineContent, line, task) {
-    const re = new RegExp(this.pattern)
-    const result = re.exec(lineContent)
-    const parseResult = result && this.parse(lineContent, line, result, task)
-
-    if (parseResult && this.config.lists && !this.config.listExists(parseResult.list)) {
-      return
-    }
-
-    return parseResult && new Task(parseResult)
-  }
-}

package/lib/adapters/readers/FileSystemProjectReader.js

@@ -1,45 +0,0 @@
-const fs = require('fs/promises')
-const path = require('path')
-const LocalFileParserFactory = require('../parsers/file/LocalFileParserFactory')
-
-module.exports = class FileSystemProjectReader {
-  async read (projectPath) {
-    // BACKLOG ## Load the config file
-    // #adapter
-    // [lib/adapters/readers/FileSystemProjectReader.js](lib/adapters/readers/FileSystemProjectReader.js)
-    // <!-- epic:"Release 2.0"
-    // order:-590
-    // -->
-    const files = await this.getFilesFromDirectory(projectPath)
-
-    // BACKLOG ## Parse project files
-    // - Loop over the files in the filesystem
-    // - Give each one a file parser and parse the file
-    //   - `const parser = LocalFileParserFactory.getFileParser(filePath, config)`
-    //   - Use worker_threads
-    // - After tasks are parsed trim the description appropriately and look for Check style tasks in what's left of the description
-    // #adapter
-    // [lib/adapters/readers/FileSystemProjectReader.js](lib/adapters/readers/FileSystemProjectReader.js)
-    // <!-- epic:"Release 2.0"
-    // order:-600
-    // -->
-
-  }
-
-  async getFilesFromDirectory (directoryPath) {
-    const filesInDirectory = await fs.readdir(directoryPath)
-    const files = await Promise.all(
-        filesInDirectory.map(async (file) => {
-            const filePath = path.join(directoryPath, file)
-            const stats = await fs.stat(filePath)
-            
-            if (stats.isDirectory()) {
-                return this.getFilesFromDirectory(filePath)
-            } else {
-                return filePath
-            }
-        })
-    )
-    return files.filter((file) => file.length)
-  }
-}

package/lib/adapters/storage/config.js

@@ -1,49 +0,0 @@
-const { readFile, writeFile, exists } = require('../file-gateway')
-const { CONFIG_DIR, CONFIG_FILE_YML } = require('../../constants')
-const { loadYAML, dumpYAML } = require('../yaml')
-const findUp = require('find-up')
-const _path = require('path')
-const Config = require('../../config')
-
-module.exports = {
-  load,
-  save,
-  loadForFilePath,
-  findImdonePath
-}
-
-async function load(projectPath, configPath = _path.join(projectPath, CONFIG_FILE_YML)) {
-  const configLike = await loadYamlConfig(configPath)
-  return configLike && new Config(configLike)
-}
-
-async function save(config, projectPath) {
-  const configPath = _path.join(projectPath, CONFIG_FILE_YML)
-  await writeFile(configPath, dumpYAML(config))
-}
-
-async function loadForFilePath(filePath) {
-  const projectPath = await findImdonePath(filePath)
-  return load(projectPath)
-}
-
-async function loadYamlConfig(filePath) {
-  if (!(await exists(filePath))) return
-  const configData = await readFile(filePath, 'utf-8')
-  let configLike = {}
-  try {
-    configLike = loadYAML(configData.toString())
-    if (configLike.exclude) delete configLike.exclude
-    if (configLike.watcher) delete configLike.watcher
-
-  } catch (e) {
-    console.error(`Error parsing config file: ${filePath}`)
-  }
-  return configLike
-}
-
-async function findImdonePath(cwd) {
-  const configDir = await findUp(CONFIG_DIR, { cwd, type: 'directory' })
-  return _path.dirname(configDir)
-}
-

package/lib/adapters/storage/tags.js

@@ -1,30 +0,0 @@
-const { readFile, writeFile, exists } = require('../file-gateway')
-const { CONFIG_DIR } = require('../../constants')
-const { loadYAML, dumpYAML } = require('../yaml')
-const _path = require('path')
-
-module.exports = {
-  load,
-  save
-}
-
-async function load(projectPath) {
-  const tagsPath = getTagsPath(projectPath)
-  if (!(await exists(tagsPath))) return
-  const tagsData = await readFile(tagsPath, 'utf-8')
-  try {
-    const { tags } = loadYAML(tagsData)
-    return tags
-  } catch (e) {
-    console.error(e)
-    return
-  }
-}
-
-async function save(tags, projectPath) {
-  await writeFile(getTagsPath(projectPath), dumpYAML({ tags }))
-}
-
-function getTagsPath(projectPath) {
-  return _path.join(projectPath, CONFIG_DIR, 'tags.yml')
-}

package/lib/adapters/yaml.js

@@ -1,6 +0,0 @@
-const YAML = require('js-yaml')
-
-module.exports = {
-  dumpYAML: YAML.dump,
-  loadYAML: YAML.load,
-}