Merge pull request #268 from atom-community/remove-rebuild-cache-events

Author: aminya

lib/autocomplete-paths.js

@@ -3,9 +3,12 @@ export { config } from "./config"
 import PathsProvider from "./paths-provider"
 import { CompositeDisposable } from "atom"
 import { OptionScopes } from "./config/option-scopes"
+import { debounce } from "underscore"
 
 const subscriptions = new CompositeDisposable()
 let _provider
+/** provider.rebuildCache method debounced */
+let _rebuildCache
 let _statusBar
 let _statusBarInterval
 let _statusBarTile
@@ -16,7 +19,7 @@ export function activate() {
   subscriptions.add(
     atom.commands.add("atom-workspace", {
       "autocomplete-paths:rebuild-cache": () => {
-        _provider.rebuildCache()
+        _rebuildCache()
       },
     })
   )
@@ -36,7 +39,7 @@ export function activate() {
           return
         }
         _provider._pathsCache.updateConfig()
-        _provider.rebuildCache()
+        _rebuildCache()
       })
     )
   })
@@ -139,7 +142,14 @@ export function getProvider() {
     _provider.on("rebuild-cache-done", () => {
       _hideStatusBarTile()
     })
-    _provider.rebuildCache()
+    _rebuildCache = debounce(
+      () => {
+        return _provider.rebuildCache()
+      },
+      1000,
+      true
+    )
+    _rebuildCache()
   }
   return _provider
 }

lib/paths-cache.js

@@ -2,6 +2,7 @@
 import { EventEmitter } from "events"
 import minimatch from "minimatch"
 import { Directory, File } from "atom"
+import { dirname, basename } from "path"
 import { union } from "./utils"
 import { globifyPath, globifyDirectory, globifyGitIgnoreFile } from "globify-gitignore"
 import glob from "fast-glob"
@@ -18,10 +19,11 @@ export default class PathsCache extends EventEmitter {
     this._projectWatcher = atom.project.onDidChangeFiles(_onDidChangeFilesBound)
 
     this._repositories = []
+    // TODO remove _filePathsByProjectDirectory and only use _filePathsByDirectory
     this._filePathsByProjectDirectory = new Map()
     this._filePathsByDirectory = new Map()
     this._fileWatchersByDirectory = new Map()
-
+    this._allIgnoredGlob = []
     this.updateConfig()
   }
 
@@ -173,15 +175,23 @@ export default class PathsCache extends EventEmitter {
     }
     // add a watcher to run `this._onDirectoryChanged`
     const projectPath = projectDirectory.getPath()
-    const ignored = await this._getAllIgnoredGlob(projectPath)
+    const ignored = this._allIgnoredGlob
     // TODO smarter handling of directory changes
     // TODO get paths from the watcher itself
     // TODO track gitignore file
     watcher = chokidar
       .watch([projectPath, ...ignored], {
         persistent: true,
+        ignoreInitial: true, // do not run the listeners on the initial scan
       })
       .on("add", (addedFile) => {
+        // we should track it too!
+        // if (basename(addedFile) === ".gitignore") {
+        //   // if a gitignore file is added re-process the folder
+        //   this.onRemoveDir(projectDirectory, removedDir)
+        //   this.onAddDir(projectDirectory, removedDir)
+        //   return
+        // }
         this.onAddFile(projectDirectory, addedFile)
       })
       .on("unlink", (removedFile) => {
@@ -201,53 +211,40 @@ export default class PathsCache extends EventEmitter {
    * @param addedFile {string}
    */
   onAddFile(projectDirectory, addedFile) {
-    this.emit("rebuild-cache")
     const filePaths = this._filePathsByProjectDirectory.get(projectDirectory.path)
     filePaths.push(addedFile)
     this._filePathsByProjectDirectory.set(projectDirectory.path, filePaths)
-    this.emit("rebuild-cache-done")
   }
 
   /**
    * @param projectDirectory {Directory}
    * @param removedFile {string}
    */
   onRemoveFile(projectDirectory, removedFile) {
-    this.emit("rebuild-cache")
     /** @type {string[]} */
     const filePaths = this._filePathsByProjectDirectory.get(projectDirectory.path)
 
     // delete the removed file
-    for (let iFile = 0; iFile < filePaths.length; iFile++) {
-      const file = filePaths[iFile]
-      if (file === removedFile) {
-        delete filePaths[iFile]
-      }
-    }
+    const fileIndex = filePaths.indexOf(removedFile)
+    delete filePaths[fileIndex]
     this._filePathsByProjectDirectory.set(projectDirectory.path, filePaths)
-    this.emit("rebuild-cache-done")
   }
 
   /**
    * @param projectDirectory {Directory}
    * @param addedDir {string}
    */
   async onAddDir(projectDirectory, addedDir) {
-    this.emit("rebuild-cache")
-    const directory = new Directory(addedDir)
-    await this._cachePathsForDirectory(projectDirectory, directory)
-    this.emit("rebuild-cache-done")
+    await this._cachePathsForDirectoryWithGlob(addedDir)
   }
 
   /**
    * @param projectDirectory {Directory}
    * @param removedDir {string}
    */
   onRemoveDir(projectDirectory, removedDir) {
-    this.emit("rebuild-cache")
     const directory = new Directory(removedDir)
     this._removeFilePathsForDirectory(projectDirectory, directory)
-    this.emit("rebuild-cache-done")
   }
 
   /**
@@ -442,18 +439,28 @@ export default class PathsCache extends EventEmitter {
   }
 
   /**
-   * Returns the glob pattern of a gitignore of a directory
-   * @param  {string} directoryPath
+   * Returns the glob pattern of all gitignore files in a directory
+   * @param  {string} rootDirectory
+   * @param {string[]} ignoredPatternsGlob
    * @returns {Promise<Array<string>>} an array of glob patterns
    * @private
    */
-  async _getGitIgnoreGlob(directoryPath) {
+  async _getAllGitIgnoreGlob(rootDirectory, ignoredPatternsGlob) {
     if (this.config.excludeVcsIgnoredPaths) {
-      try {
-        return await globifyGitIgnoreFile(directoryPath)
-      } catch (err) {
-        // .gitignore does not exist for this directory, ignoring
-      }
+      // get gitignore files
+      const gitignoreFiles = await glob(
+        ["**/.gitignore", ...ignoredPatternsGlob],
+        // glob options
+        {
+          dot: true,
+          cwd: rootDirectory,
+          onlyFiles: true,
+          absolute: true,
+        }
+      )
+      return (
+        await Promise.all(gitignoreFiles.map((gitignoreFile) => _getDirectoryGitIgnoreGlob(dirname(gitignoreFile))))
+      ).flat()
     }
     return []
   }
@@ -464,8 +471,8 @@ export default class PathsCache extends EventEmitter {
    * @returns {Promise<string[]>}
    */
   async _getAllIgnoredGlob(directoryPath) {
-    const gitignoreGlob = await this._getGitIgnoreGlob(directoryPath)
     const ignoredPatternsGlob = await this._getIgnoredPatternsGlob(directoryPath)
+    const gitignoreGlob = await this._getAllGitIgnoreGlob(directoryPath, ignoredPatternsGlob)
     return [...gitignoreGlob, ...ignoredPatternsGlob]
   }
 
@@ -477,8 +484,9 @@ export default class PathsCache extends EventEmitter {
    */
   async _cachePathsForDirectoryWithGlob(directoryPath) {
     const directoryGlob = globifyDirectory(directoryPath)
+    this._allIgnoredGlob = await this._getAllIgnoredGlob(directoryPath)
     const files = await glob(
-      [directoryGlob, ...(await this._getAllIgnoredGlob(directoryPath))],
+      [directoryGlob, ...this._allIgnoredGlob],
       // glob options
       {
         dot: true,
@@ -566,3 +574,18 @@ export default class PathsCache extends EventEmitter {
     return Promise.all(directories.map((dir) => this._cachePathsForDirectoryWithAtom(projectDirectory, dir)))
   }
 }
+
+/**
+ * Returns the glob pattern of a gitignore of a directory
+ * @param  {string} directoryPath
+ * @returns {Promise<Array<string>>} an array of glob patterns
+ * @private
+ */
+function _getDirectoryGitIgnoreGlob(directoryPath) {
+  try {
+    return globifyGitIgnoreFile(directoryPath)
+  } catch (err) {
+    // .gitignore does not exist for this directory, ignoring
+    return []
+  }
+}