Deeply nested repo (#4810)

* Get deeply nested DVC repo as dvc roots

* Fix tests

* Fix lint error

* Add test

* Simplify search of roots

Author: sroy3

extension/src/cli/dvc/constants.ts

@@ -3,6 +3,9 @@ import { join } from 'path'
 export const UNEXPECTED_ERROR_CODE = 255
 export const DOT_DVC = '.dvc'
 
+const NESTED_DVC = join(DOT_DVC, 'config')
+export const FULLY_NESTED_DVC = join('**', NESTED_DVC)
+
 export const TEMP_DAG_FILE = join(DOT_DVC, 'tmp', 'dag.md')
 
 export const TEMP_PLOTS_DIR = join(DOT_DVC, 'tmp', 'plots')

extension/src/fileSystem/index.test.ts

@@ -1,9 +1,7 @@
 import { join, relative, resolve } from 'path'
 import {
   appendFileSync,
-  ensureDirSync,
   ensureFileSync,
-  remove,
   readFileSync,
   writeFileSync
 } from 'fs-extra'
@@ -55,8 +53,10 @@ const mockedWorkspace = jest.mocked(workspace)
 const mockedWindow = jest.mocked(window)
 const mockedOpenTextDocument = jest.fn()
 const mockedShowTextDocument = jest.fn()
+const mockedFindFiles = jest.fn()
 
 mockedWorkspace.openTextDocument = mockedOpenTextDocument
+mockedWorkspace.findFiles = mockedFindFiles
 mockedWindow.showTextDocument = mockedShowTextDocument
 
 beforeEach(() => {
@@ -275,41 +275,67 @@ describe('writeTsv', () => {
 })
 
 describe('findDvcRootPaths', () => {
+  const convertAsFindDvcConfigFile = (rootPath: string) => ({
+    fsPath: join(rootPath, DOT_DVC, 'config')
+  })
+
   it('should find the dvc root if it exists in the given folder', async () => {
-    const dvcRoots = await findDvcRootPaths(dvcDemoPath)
+    mockedFindFiles.mockResolvedValue([convertAsFindDvcConfigFile(dvcDemoPath)])
+    const dvcRoots = await findDvcRootPaths()
 
-    expect(dvcRoots).toStrictEqual([dvcDemoPath])
+    expect(dvcRoots).toStrictEqual(new Set([dvcDemoPath]))
   })
 
   it('should find multiple roots if available one directory below the given folder', async () => {
     const parentDir = resolve(dvcDemoPath, '..')
     const mockDvcRoot = join(parentDir, 'mockDvc')
-    ensureDirSync(join(mockDvcRoot, DOT_DVC))
-
-    const dvcRoots = await findDvcRootPaths(parentDir)
+    mockedFindFiles.mockResolvedValue([
+      convertAsFindDvcConfigFile(dvcDemoPath),
+      convertAsFindDvcConfigFile(mockDvcRoot)
+    ])
 
-    void remove(mockDvcRoot)
+    const dvcRoots = await findDvcRootPaths()
 
-    expect([...dvcRoots]).toStrictEqual([dvcDemoPath, mockDvcRoot])
+    expect(dvcRoots).toStrictEqual(new Set([dvcDemoPath, mockDvcRoot]))
   })
 
   it('should find a mono-repo root as well as sub-roots if available one directory below the given folder', async () => {
-    const parentDir = dvcDemoPath
-    const mockFirstDvcRoot = join(parentDir, 'mockFirstDvc')
-    const mockSecondDvcRoot = join(parentDir, 'mockSecondDvc')
-    ensureDirSync(join(mockFirstDvcRoot, DOT_DVC))
-    ensureDirSync(join(mockSecondDvcRoot, DOT_DVC))
+    const mockFirstDvcRoot = join(dvcDemoPath, 'mockFirstDvc')
+    const mockSecondDvcRoot = join(dvcDemoPath, 'mockSecondDvc')
+    mockedFindFiles.mockResolvedValue([
+      convertAsFindDvcConfigFile(dvcDemoPath),
+      convertAsFindDvcConfigFile(mockFirstDvcRoot),
+      convertAsFindDvcConfigFile(mockSecondDvcRoot)
+    ])
 
-    const dvcRoots = await findDvcRootPaths(parentDir)
+    const dvcRoots = await findDvcRootPaths()
 
-    void remove(mockFirstDvcRoot)
-    void remove(mockSecondDvcRoot)
+    expect(dvcRoots).toStrictEqual(
+      new Set([dvcDemoPath, mockFirstDvcRoot, mockSecondDvcRoot])
+    )
+  })
 
-    expect([...dvcRoots]).toStrictEqual([
+  it('should find deeply nested roots if available', async () => {
+    const mockFirstDvcRoot = join(
       dvcDemoPath,
-      mockFirstDvcRoot,
-      mockSecondDvcRoot
+      'deep',
+      'deeper',
+      'really_deep',
+      'one'
+    )
+    const mockSecondDvcRoot = join(dvcDemoPath, 'one_deep', 'two')
+
+    mockedFindFiles.mockResolvedValue([
+      convertAsFindDvcConfigFile(dvcDemoPath),
+      convertAsFindDvcConfigFile(mockFirstDvcRoot),
+      convertAsFindDvcConfigFile(mockSecondDvcRoot)
     ])
+
+    const dvcRoots = await findDvcRootPaths()
+
+    expect(dvcRoots).toStrictEqual(
+      new Set([dvcDemoPath, mockFirstDvcRoot, mockSecondDvcRoot])
+    )
   })
 })
 

extension/src/fileSystem/index.ts

@@ -6,7 +6,8 @@ import {
   relative,
   resolve,
   sep,
-  format
+  format,
+  dirname
 } from 'path'
 import {
   appendFileSync,
@@ -22,13 +23,14 @@ import { Uri, workspace, window, commands, ViewColumn } from 'vscode'
 import { csv2json, json2csv } from 'json-2-csv'
 import yaml from 'yaml'
 import { standardizePath } from './path'
+import { findFiles } from './workspace'
 import { definedAndNonEmpty, sortCollectedArray } from '../util/array'
 import { Logger } from '../common/logger'
 import { gitPath } from '../cli/git/constants'
 import { createValidInteger } from '../util/number'
 import { processExists } from '../process/execution'
 import { getFirstWorkspaceFolder } from '../vscode/workspaceFolders'
-import { DOT_DVC } from '../cli/dvc/constants'
+import { DOT_DVC, FULLY_NESTED_DVC } from '../cli/dvc/constants'
 import { delay } from '../util/time'
 import { PlotConfigData, PlotConfigDataAxis } from '../pipeline/quickPick'
 
@@ -65,20 +67,17 @@ export const findSubRootPaths = async (
     .map(child => standardizePath(join(cwd, child)))
 }
 
-export const findDvcRootPaths = async (cwd: string): Promise<string[]> => {
+export const findDvcRootPaths = async (): Promise<Set<string>> => {
   const dvcRoots = []
 
-  if (isDirectory(join(cwd, DOT_DVC))) {
-    dvcRoots.push(standardizePath(cwd))
-  }
-
-  const subRoots = await findSubRootPaths(cwd, DOT_DVC)
-
-  if (definedAndNonEmpty(subRoots)) {
-    dvcRoots.push(...subRoots)
+  const nested = await findFiles(FULLY_NESTED_DVC)
+  if (definedAndNonEmpty(nested)) {
+    dvcRoots.push(
+      ...nested.map(nestedRoot => standardizePath(dirname(dirname(nestedRoot))))
+    )
   }
 
-  return sortCollectedArray(dvcRoots)
+  return new Set(sortCollectedArray(dvcRoots))
 }
 
 export const findAbsoluteDvcRootPath = async (

extension/src/setup/index.ts

@@ -467,12 +467,10 @@ export class Setup
   }
 
   private async findWorkspaceDvcRoots() {
-    let dvcRoots: Set<string> = new Set()
+    const dvcRoots: Set<string> = await findDvcRootPaths()
 
     for (const workspaceFolder of getWorkspaceFolders()) {
-      const workspaceFolderRoots = await findDvcRootPaths(workspaceFolder)
-      if (definedAndNonEmpty(workspaceFolderRoots)) {
-        dvcRoots = new Set([...dvcRoots, ...workspaceFolderRoots])
+      if ([...dvcRoots].filter(root => root.includes(workspaceFolder))) {
         continue
       }
 

extension/src/test/suite/setup/util.ts

@@ -80,7 +80,7 @@ export const buildSetup = ({
   const mockInitializeGit = stub(gitExecutor, 'gitInit')
 
   stub(FileSystem, 'findDvcRootPaths').resolves(
-    [mockDvcRoot].filter(Boolean) as string[]
+    new Set([mockDvcRoot].filter(Boolean) as string[])
   )
 
   const mockAutoInstallDvc = stub(AutoInstall, 'autoInstallDvc')