imdone-core 2.0.0 → 2.0.1

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

@@ -0,0 +1,367 @@
+import eol from 'eol'
+import XRegExp from 'xregexp'
+
+export const FILE_TYPES = {
+  MARKDOWN: 'markdown',
+  CODE: 'code',
+}
+export 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]+(.+)$'
+
+export const LIST_NAME_PATTERN = '[\\p{L}0-9-_]{2,}' // [a-zA-Z-_]+?
+export const LINK_STYLE_REGEX = new XRegExp(
+  `(\\[.*\\]\\s?)?(\\[(.+)\\]\\(#(${LIST_NAME_PATTERN})(:)(-?[\\d.]+(?:e-?\\d+)?)?\\))`,
+  'gm'
+)
+
+export const CHECK_REGEX = /^(\s*- )\[([x ])\]/
+
+export 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'
+    )
+}
+
+export 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
+}
+
+export 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;
+}
+
+export 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)
+}
+
+export 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,
+  }
+}
+
+export function getTaskContent ({
+  config,
+  content,
+  inBlockComment,
+  beforeText,
+  fileType,
+  lang  
+}) {
+  return getCardTagsTaskContent({ content, fileType }) ||
+    getCodeFileTaskContent({ config, content, inBlockComment, fileType, lang }) ||
+    getTextFileTaskContent({ config, content, beforeText, fileType })
+}
+
+export 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}`  
+  } 
+}
+
+export function isNumber(value) {
+  return !isNaN(value) && isFinite(Number(value));
+}
+
+export function toNumber(value) {
+  if (value == null || value == undefined) return undefined; // Convert null or undefined to undefined
+  const num = Number(value);
+  return isNaN(num) ? undefined : num; // Return 0 if conversion fails, otherwise return the number
+}

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

@@ -0,0 +1,28 @@
+import { TaskParser } from "./TaskParser.js"
+
+export 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

@@ -0,0 +1,24 @@
+import { TaskParser } from './TaskParser.js'
+
+export 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

@@ -0,0 +1,27 @@
+import { TaskParser } from './TaskParser.js'
+import { getHashStyleRegex } from './CardContentParser.js'
+
+export 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

@@ -0,0 +1,24 @@
+import { TaskParser } from './TaskParser.js'
+
+export 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

@@ -0,0 +1,38 @@
+
+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
+  }
+}
+
+export 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/parsers/task/index.js

@@ -0,0 +1,6 @@
+export * from './CardContentParser.js';
+export * from './CheckStyleTaskParser.js';
+export * from './CodeStyleTaskParser.js';
+export * from './HashStyleTaskParser.js';
+export * from './MarkdownStyleTaskParser.js';
+export * from './TaskParser.js';

package/lib/adapters/storage/config.js

@@ -0,0 +1,44 @@
+import { readFile, writeFile, exists } from '../file-gateway.js'
+import { constants } from '../../constants.js'
+import { loadYAML, dumpYAML } from '../yaml.js'
+import { findUp } from 'find-up-simple'
+import _path from 'path'
+import { Config } from '../../config.js'
+import { logger } from '../logger.js'
+
+const { CONFIG_DIR, CONFIG_FILE_YML } = constants
+export async function load(projectPath, configPath = _path.join(projectPath, CONFIG_FILE_YML)) {
+  const configLike = await loadYamlConfig(configPath)
+  return configLike && new Config(configLike)
+}
+
+export async function save(config, projectPath) {
+  const configPath = _path.join(projectPath, CONFIG_FILE_YML)
+  await writeFile(configPath, dumpYAML(config))
+}
+
+export async function loadForFilePath(filePath) {
+  const projectPath = await findImdonePath(filePath)
+  return load(projectPath)
+}
+
+export 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) {
+    logger.error(`Error parsing config file: ${filePath}`)
+  }
+  return configLike
+}
+
+export async function findImdonePath(cwd) {
+  const configDir = await findUp(CONFIG_DIR, { cwd, type: 'directory' })
+  return _path.dirname(configDir)
+}
+

package/lib/adapters/storage/index.js

@@ -0,0 +1,2 @@
+export * from './config.js';
+export * from './tags.js';

package/lib/adapters/storage/tags.js

@@ -0,0 +1,29 @@
+import { readFile, writeFile, exists } from '../file-gateway.js'
+import { constants } from '../../constants.js'
+const { CONFIG_DIR } = constants
+import { loadYAML, dumpYAML } from '../yaml.js'
+import _path from 'path'
+import { logger } from '../logger.js'
+
+export const TAGS_FILE_PATH = _path.join(CONFIG_DIR, 'tags.yml')
+
+export 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) {
+    logger.error(e)
+    return
+  }
+}
+
+export async function save(tags, projectPath) {
+  await writeFile(getTagsPath(projectPath), dumpYAML({ tags }))
+}
+
+function getTagsPath(projectPath) {
+  return _path.join(projectPath, TAGS_FILE_PATH)
+}

package/lib/adapters/yaml.js

@@ -0,0 +1,9 @@
+import YAML from 'js-yaml'
+
+export function dumpYAML(obj, opts) {
+  return YAML.dump(obj, opts)
+}
+
+export function loadYAML(str, opts) {
+  return YAML.load(str, opts)
+}