imdone-core 2.0.0 → 2.0.1

package/lib/mixins/repo-fs-store.js

@@ -0,0 +1,359 @@
+import _path from 'path'
+import _cloneDeep from 'lodash.clonedeep'
+import _isFunction from 'lodash.isfunction'
+import _isUndefined from 'lodash.isundefined'
+import _assign from 'lodash.assign'
+import _remove from 'lodash.remove'
+import _union from 'lodash.union'
+import { eachLimit } from 'async'
+import { computeChecksum } from '../checksum.js'
+import { constants } from '../constants.js'
+import debug from 'debug'
+const log = debug('imdone-mixins:repo-fs-store.js')
+import { File } from '../file.js'
+import { Config } from '../config.js'
+import { languages } from '../languages.js'
+import { isBinaryFile } from 'isbinaryfile'
+import eol from 'eol'
+const _eol = String(eol.auto)
+import readdirp from 'readdirp'
+import _ignore from 'ignore'
+import { sort } from 'fast-sort'
+import { buildMigrateConfig } from '../migrate-config.js'
+import { loadYAML, dumpYAML } from '../adapters/yaml.js';
+import realFs, { readFileSync } from 'fs'
+import { preparePathForWriting, readFile, writeFile, stat, lstat, unlink } from '../adapters/file-gateway.js'
+
+const {
+  CONFIG_FILE,
+  CONFIG_FILE_YML,
+  ASYNC_LIMIT,
+  DEFAULT_IGNORE_PATHS,
+  DEFAULT_IGNORE_EXTS,
+  IGNORE_FILE,
+  SORT_FILE,
+  ERRORS,
+} = constants
+
+const { DEFAULT_CONFIG } = Config
+
+export function fileSystemStoreMixin(repo, fs = realFs) {
+  repo.allFiles = []
+
+  function getIgnorePatterns() {
+    var ignoreFile = _path.join(repo.path, IGNORE_FILE)
+    let patterns = DEFAULT_IGNORE_PATHS
+    if (fs.existsSync(ignoreFile))
+      patterns = patterns + _eol + fs.readFileSync(ignoreFile).toString()
+
+    return patterns
+  }
+
+  const IG = _ignore().add(getIgnorePatterns())
+
+  function shouldIncludeFile(entry) {
+    const { path, dirent } = entry
+    return !dirent.isSymbolicLink() && !IG.ignores(path)
+  }
+
+  repo.getAllFilePaths = async function (root) {
+    const entries = []
+    for await (const entry of readdirp(root, { lstat: true, fileFilter: shouldIncludeFile })) {
+      entries.push(entry)
+    }
+    return entries.filter((res) => repo.shouldInclude(res.path))
+      .map((res) => res.fullPath)
+  }
+
+  repo.addFilePath = async function (path) {
+    var relPath = repo.getRelativePath(path)
+    var fullPath = repo.getFullPath(path)
+
+    const stat = await fs.promises.lstat(fullPath)
+    if (stat.isDirectory()) relPath += _path.sep
+    if (!repo.allFiles.includes(relPath)) {
+      repo.allFiles.push(relPath)
+    }
+  }
+
+  repo.removeFilePath = function (path) {
+    _remove(repo.allFiles, (item) => item === path)
+  }
+
+  repo.getFilePaths = function () {
+    return repo.allFiles
+  }
+
+  repo.migrateConfig = buildMigrateConfig(repo)
+  // READY Refactor init to use async/await
+  // #esm-migration #important #urgent
+  // <!--
+  // order:-270
+  // -->
+  repo.init = async function () {
+    const stats = await stat(repo.path)
+    if (!stats.isDirectory()) {
+      var error = new Error(
+        `Path must be an existing directory on the file system: ${repo.path}`
+      )
+      repo.emit('error', error)
+      throw error
+    }
+
+    await repo.loadConfig()
+    repo.migrateConfig()
+    await repo.saveConfig()
+    repo.emit('config.loaded')
+    repo.createListeners()
+    
+    const files = await repo.readFiles()
+    const lists = repo.getTasksByList()
+    repo.emit('fs-store-initialized', { ok: true, lists })
+    return files
+  }
+
+  repo.loadIgnore = function () {
+    const patterns = getIgnorePatterns() + _eol + DEFAULT_IGNORE_EXTS
+    repo.setIgnores(patterns)
+  }
+
+  repo.fileOK = async function (file, includeDirs = false) {
+    if (File.isFile(file)) file = file.path
+    if (!file || !this.shouldInclude(file)) return false
+
+    var fullPath = repo.getFullPath(file)
+    try {
+      const stats = await lstat(fullPath)
+      
+      if (!stats) return false
+      
+      if (/\.\.(\/|\\)/.test(file) || (!includeDirs && stats.isDirectory()))
+        return false
+          
+      const content = await readFile(fullPath)
+      
+      if (await isBinaryFile(content, stats.size) ) {
+        return false
+      }
+      
+      return stats
+    } catch (err) {
+      return false
+    }
+  }
+
+  // READY Refactor saveSort to use async/await
+  // #esm-migration #important
+  // TODO readSort and saveSort are no longer used
+  repo.saveSort = async function (sort) {
+    writeFile(repo.getFullPath(SORT_FILE), JSON.stringify(sort), 'utf8')
+  }
+
+  repo.readSort = async function () {
+    const data = readFile(repo.getFullPath(SORT_FILE))
+    repo.sort = JSON.parse(data)
+  }
+
+  repo.saveConfig = async function () {
+    try {
+      repo.savingConfig = true
+      const file = repo.getFullPath(CONFIG_FILE_YML)
+      const data = { ...repo.getConfig() }
+      delete data.cardActionsFunction
+      delete data.boardActionsFunction
+      delete data.cardPropertiesFunction
+      delete data.path
+      if (data.lists) data.lists.forEach((list) => delete list.tasks)
+      const yaml = dumpYAML(data)
+      await preparePathForWriting(file)
+      await writeFile(file, yaml)
+    } finally {
+      repo.savingConfig = false
+    }
+  }
+
+  repo.updateConfig = async function (loadedConfig) {
+    var baseConfig = _cloneDeep(DEFAULT_CONFIG)
+    var include_lists = baseConfig.code.include_lists
+    const currentConfig = repo.config
+    if (currentConfig && currentConfig.code)
+      include_lists = _union(include_lists, currentConfig.code.include_lists)
+
+    if (currentConfig && currentConfig.settings)
+      loadedConfig.settings = {...currentConfig.settings, ...loadedConfig.settings}
+
+    if (loadedConfig && loadedConfig.code)
+      include_lists = _union(include_lists, loadedConfig.code.include_lists)
+
+    const newConfig = new Config(
+      _assign({}, baseConfig, repo.config, loadedConfig, { path: repo.path })
+    )
+
+    await repo.migrateTasksByConfig(currentConfig, newConfig)
+    repo.config = newConfig
+    repo.config.code.include_lists = include_lists
+    var _languages = _cloneDeep(languages)
+    repo.languages = repo.config.languages
+      ? _assign(_languages, repo.config.languages)
+      : _languages
+    return repo.config
+  }
+
+  // READY Refactor loadConfig to use async/await
+  // #esm-migration
+  // <!--
+  // order:-255
+  // -->
+  repo.loadConfig = async function (cb) {
+    // BACKLOG If a config is bad move it to config.json.bak and save a new one with defaults gh:2 id:9 +enhancement +standup +chore
+    // <!--
+    // order:-670
+    // -->
+    repo.loadIgnore()
+    const configData =  (!repo.config || repo.config.dirty) 
+    ? await this.getYamlConfig() 
+    : repo.config || {}
+    
+    return await repo.updateConfig(configData)
+  }
+
+  repo.getConfigFile = function () {
+    return repo.getFullPath(CONFIG_FILE)
+  }
+
+  repo.getYamlConfig = async function () {
+    const filePath = repo.getFullPath(CONFIG_FILE_YML)
+    if (!fs.existsSync(filePath)) return
+    const configData = await readFile(filePath, 'utf-8')
+    let configLike = {}
+    try {
+      configLike = loadYAML(configData.toString())
+    } catch (e) {
+      /* noop */
+    }
+    return configLike
+  }
+
+  // READY Refactor writeFile to use async/await
+  // #esm-migration #important
+  // <!--
+  // order:-280
+  // -->
+  repo.writeFile = async (file, emitFileUpdate) => {
+    if (!File.isFile(file)) throw new Error(ERRORS.NOT_A_FILE)
+    if (file.deleted) return file
+    
+    if (/\.\.(\/|\\)/.test(file.path)) throw new Error('Unable to write file:' + file.path)
+
+    const filePath = repo.getFullPath(file)
+    
+    await preparePathForWriting(filePath)
+
+    const oldChecksum = file.checksum
+    file.checksum = computeChecksum(file.getContentForFile())
+        
+    try {
+      await writeFile(filePath, file.getContentForFile(), 'utf8')
+    } catch (err) {
+      file.checksum = oldChecksum
+      throw new Error('Unable to write file:' + filePath, {cause: err})
+    }
+
+    try {
+      const stats = await stat(filePath)
+      file.setModifiedTime(stats.mtime)
+      file.modified = false
+      repo.addFilePath(filePath)
+      if (emitFileUpdate) repo.emit('file.saved', file)
+    } catch (err) {
+      throw new Error('Unable to stat file:' + filePath, {cause: err})
+    }
+  
+    return file      
+  }
+
+  // READY Refactor getFilesInPath to use async/await
+  // #esm-migration #important #urgent
+  // <!--
+  // order:-20
+  // -->
+  repo.getFilesInPath = async function (includeDirs) {
+    const allPaths = await repo.getAllFilePaths(repo.path)
+    const files = []
+    let processed = 0
+    log('allPaths=', allPaths)
+    if (allPaths.length === 0) return files
+    await eachLimit(
+      allPaths,
+      ASYNC_LIMIT,
+      async (path) => {
+        if (!path) return
+        path = repo.getRelativePath(path)
+        const stat = await repo.fileOK(path, includeDirs)
+        processed++
+        repo.emit('file.processed', {
+          file: path,
+          ok: stat !== false,
+          total: allPaths.length,
+          processed: processed + 1,
+          repoId: repo.getId(),
+        })
+
+        if (stat) {
+          log('%s is ok %j', path, stat)
+          var file = new File({
+            repoId: repo.getId(),
+            filePath: path,
+            modifiedTime: stat.mtime,
+            createdTime: stat.birthtime,
+            languages: repo.languages,
+            project: repo.project,
+          })
+          file.isDir = stat.isDirectory()
+          files.push(file)
+        }
+        log('stat=%j', stat, null)
+        log('processed=%d allPaths.length=%d', processed, allPaths.length)
+      })
+      return sort(files).asc(u => u.path)
+  }
+
+  // READY Refactor readFileContent to use async/await
+  // #esm-migration #important #urgent
+  // <!--
+  // order:-40
+  // -->
+  repo.readFileContent = async function (file) {
+    if (!File.isFile(file)) throw new Error(ERRORS.NOT_A_FILE)
+    var filePath = repo.getFullPath(file)
+
+    const stats = await stat(filePath)
+    if (!stats.isFile()) return file
+    const data = await readFile(filePath, 'utf8')
+
+    file
+      .setContentFromFile(data)
+      .setModifiedTime(stats.mtime)
+      .setCreatedTime(stats.birthtime)
+
+    file.lineCount = eol.split(data).length
+    return file
+  }
+
+  // READY Refactor deleteFile to use async/await
+  // #esm-migration #important
+  repo.deleteFile = async function (path) {
+    const file = File.isFile(path) ? path : repo.getFile(path)
+    if (!file) throw new Error('Unable to delete:' + path)
+
+    try {
+      await unlink(repo.getFullPath(file))
+      repo.removeFile(file)
+    } catch (err) {
+      throw new Error('Unable to delete file:' + path, {cause: err})
+    }
+
+  }
+
+  return repo
+}

package/lib/mixins/repo-watched-fs-store.js

@@ -0,0 +1,206 @@
+import { fileSystemStoreMixin } from './repo-fs-store.js'
+import debug from 'debug'
+const log = debug('imdone-mixins:repo-watched-fs-store')
+import { File } from '../file.js'
+import { constants } from '../constants.js'
+import chokidar from 'chokidar'
+import realFs from 'fs'
+import { logger } from '../adapters/logger.js'
+
+// BACKLOG Only emit file.update if the file checksum has changed
+// <!--
+// order:-650
+// -->
+export function watchedFileSystemStoreMixin(repo, fs = realFs) {
+  repo = fileSystemStoreMixin(repo, fs)
+  const _refresh = repo.refresh
+  const _destroy = repo.destroy
+  const _init = repo.init
+  let initializing = false
+  let refreshing = false
+
+  function ready() {
+    return !initializing && !refreshing
+  }
+
+  async function waitForReady() {
+    while (!ready()) {
+      logger.log('Waiting for repo to be ready:', repo.path)
+      await new Promise(resolve => setTimeout(resolve, 500))
+    }
+  }
+
+  // READY Refactor init to async/await
+  // #esm-migration #important
+  // <!--
+  // order:-310
+  // -->
+  repo.init = async function () {
+    if (initializing) {
+      throw new Error("Can't initialize repo while it's initializing.")
+    }
+    log('Initializing repo:', repo.path)
+    initializing = true
+    try {
+      const files = await _init.call(repo)
+      await repo.initWatcher()
+      repo.emit('watching', { ok: true, lists: repo.getLists() })
+      initializing = false
+      return files
+    } catch (err) {
+      initializing = false
+      throw new Error(`Error initializing repo: ${repo.path}`, { cause: err })
+    }
+  }
+
+  repo.destroy = async function () {
+    if (repo.watcher) await repo.watcher.close()
+    await _destroy.apply(repo)
+  }
+
+  // READY Refactor refresh to async/await
+  // #esm-migration #important
+  // <!--
+  // order:-330
+  // -->
+  repo.refresh = async function () {
+    await waitForReady()
+    log('Refreshing repo:', repo.path)
+    refreshing = true
+    try {
+      const files = await _refresh.call(repo)
+      await repo.initWatcher()
+      refreshing = false
+      return files
+    } catch (err) {
+      refreshing = false
+      throw new Error(`Error refreshing repo: ${repo.path}`, { cause: err })
+    }
+
+  }
+
+  function _isImdoneConfig(path) {
+    return path === constants.CONFIG_FILE_YML
+  }
+
+  function _isImdoneIgnore(path) {
+    return path === constants.IGNORE_FILE
+  }
+
+  async function onConfigChange(file) {
+    logger.info('Loading config.  Observed a change to:', file)
+    const label = `Refresh repo: ${repo.path}`
+    logger.time(label)
+    try {
+      await repo.refresh()
+      repo.emitConfigUpdate(file, repo.config)
+    } finally {
+      logger.timeEnd(label)
+    }
+  }
+
+  const onIgnoreChange = onConfigChange
+
+  // READY Refactor initWatcher to async/await
+  // #esm-migration #important
+  // <!--
+  // order:-320
+  // defer:2025-03-18
+  // -->
+  repo.initWatcher = async () => {
+    return new Promise(async (resolve, reject) => {
+      logger.log('initializing watcher for:', repo.path)
+      repo.watcher = chokidar.watch(repo.path, {
+        persistent: true,
+        usePolling: false,
+        alwaysStat: true,
+        awaitWriteFinish: true,
+        atomic: true,
+        ignoreInitial: true,
+        ignored: (file) => {
+          const ignored = !repo.shouldInclude(file)
+          if (ignored) logger.log('Ignoring file:', file)
+          return ignored
+        }
+      }).on('error', (err) => {
+          logger.error('Error in watcher')
+          logger.error(err)
+          repo.emit('watch.error', err)
+          reject(err)
+        })
+        .on('ready', () => {
+          logger.log('watcher ready for:', repo.path)
+          initializing = false
+          resolve()
+        })
+        .on('add', async function (path, stat) {
+          logger.log('Watcher received add event for file: ' + path)
+          if (stat.isDirectory()) return
+          let file = repo.getFile(path)
+          if (file === undefined) {
+            log('Creating file: ' + path)
+            file = new File({
+              repoId: repo.getId(),
+              filePath: path,
+              languages: repo.languages,
+              project: repo.project,
+            })
+          }
+
+          stat = await repo.fileOK()
+          log('fileOK returned: ' + JSON.stringify(stat))
+          if (stat.mtime <= file.getModifiedTime()) {
+            return log('File update already applied.  Change ignored for file: ' + path)
+          }
+          log('Reading file: ' + path)
+          file = await repo.readFile(file)
+          repo.emi('watch.add', file)
+          repo.emitFileUpdate(file)
+        })
+        .on('change', async function (path, stat) {
+          logger.log(
+            `Watcher received change event for file: ${path} repoPath: ${repo.path}`,
+            stat.mtime
+          )
+          if (!path || stat.isDirectory()) return
+          var file = repo.getFile(path) || path
+          const isFile = File.isFile(file)
+          // BACKLOG ## Handle the case where the file is not in the repo
+          // #urgent #1.12.0
+          // <!--
+          // order:-660
+          // -->
+          if (isFile && stat.mtime <= file.getModifiedTime()) {
+            // logger.log("File update already applied.  Change ignored.")
+            return
+          }
+          if (_isImdoneConfig(path)) return onConfigChange(path)
+          if (_isImdoneIgnore(path)) return onIgnoreChange(path)
+
+          const ok = await repo.fileOK((file && file.path) || path)
+          if (!ok) return
+          log('Reading file: ' + path)
+          if (!isFile) file = repo.getFile(path)
+          file = await repo.readFile(file)
+          repo.emit('watch.change', file)
+          repo.emitFileUpdate(file)
+        })
+        .on('delete', async function (path) {
+          log('Watcher received unlink event for file: ' + path)
+          repo.removeFilePath(path)
+          var file = new File({
+            repoId: repo.getId(),
+            filePath: path,
+            languages: repo.languages,
+            project: repo.project,
+          })
+          log('Removing file: ' + path)
+          repo.removeFile(file)
+          repo.emit('watch.delete', file)
+          repo.emitFileUpdate(file, true)
+        })
+    });
+  }
+
+  return repo
+}

package/lib/plugins/archive-plugin.js

@@ -0,0 +1,72 @@
+import Plugin from 'imdone-api'
+import path from 'path'
+import { getRawTask } from '../adapters/parsers/task/CardContentParser.js'
+
+export default class ArchivePlugin extends Plugin {
+  constructor(project) {
+    super(project)
+  }
+
+  get config() {
+    return this.project.config
+  }
+
+  get fileGateway() {
+    return this.project.fileGateway
+  }
+
+  async onBeforeBoardUpdate() {
+    const config = this.config
+    if (!config || !config.archiveCompleted || this.archivingTasks) return
+    this.archivingTasks = true
+    const cards = this.project.getAllCards(`meta.archived != "true" and list = ${config.doneList}`)
+    const messageUser = cards.length > 1
+
+    if (!cards.length) {
+      this.archivingTasks = false
+      return
+    } else {
+      if (messageUser) this.project.snackBar({message: `Archiving ${cards.length} card(s)...`})
+    }
+
+    for (const card of cards) {
+      await this.archiveTask(card)
+    }
+
+    if (messageUser) this.project.snackBar({message: ` Done archiving ${cards.length} card(s). Deleting original(s)...`})
+    await this.project.deleteTasks(cards)
+
+    this.archivingTasks = false
+    if (messageUser) this.project.snackBar({message: `Done deleting original card(s).`})
+
+  }
+
+  async archiveTask (task, config = this.config) {
+    const archiveFolder = config.archiveFolder
+    const fileDir = path.dirname(task.relPath)
+    
+    if (fileDir.startsWith(archiveFolder)) return
+
+    const fileName = this.fileGateway.sanitizeFileName(`${task.text}.md`, config.replaceSpacesWith)
+    const newPath = path.join(this.project.path, archiveFolder, fileDir, fileName)
+    
+    const content = this.project.addMetaToContent(
+      [
+        { key: 'archived', value: 'true'},
+        { key: 'archivedAt', value: this.project.isoDateWithOffset },
+        { key: 'originalPath', value: task.relPath },
+        { key: 'originalLine', value: task.line }
+      ], 
+      task.content
+    )
+
+    const { tokenPrefix } = config
+    const { beforeText, list } = task
+    const taskStart = getRawTask({tokenPrefix, beforeText, list, text: ''})
+    const taskContent = `${taskStart} ${content}\n\n\n`
+    
+    await this.fileGateway.preparePathForWriting(newPath)
+    await this.fileGateway.appendFileSync(newPath, taskContent)
+  }
+
+}

package/lib/plugins/default-board-actions-plugin.js

@@ -0,0 +1,56 @@
+import Plugin from 'imdone-api'
+
+export default class DefaultBoardActionsPlugin extends Plugin {
+  constructor(project) {
+    super(project)
+  }
+
+  getBoardActions() {
+    const project = this.project
+    const isWindows = process.platform === 'win32'
+    const openIn = isWindows ? 'Explorer' : 'Finder'
+
+    return [
+      {
+        title: 'Duplicate card',
+        keys: ['shift+d'],
+        icon: 'clone',
+        action: async (task) => {
+          const timestamp = project.isoDateWithOffset
+          await project.newCard({
+            list: project.config.getDefaultList(),
+            path: task.relPath,
+            template: task.content.replace(/(\screated:).*(\s)/, `$1${timestamp}$2`),
+          })
+          project.toast({ message: `"${task.text}" duplicated` })
+        },
+      },
+      {
+        title: 'Copy card to clipboard',
+        keys: ['c'],
+        icon: 'clone',
+        action: (task) => {
+          return project.copyToClipboard(task.content, `"${task.text} markdown" copied to clipboard`)
+        },
+      },
+      {
+        title: 'Copy card title to clipboard',
+        keys: ['mod+t'],
+        icon: 'clone',
+        action: (task) => {
+          const title = project.renderMarkdown(task.text, task.fullPath).replaceAll(/<\/*p>/gi, '')
+          return project.copyToClipboard(title, `"${title}" copied to clipboard`)
+        },
+      },
+      {
+        title: `Open in ${openIn}`,
+        keys: ['alt+shift+o'],
+        icon: "folder",
+        async action () {
+          await project.openPath(project.path)
+        }
+      }  
+    ]
+  }
+  
+}