Code coverage report for utils.ts

# All files utils.ts

100% Statements 6/6
100% Branches 6/6
100% Functions 2/2
100% Lines 6/6

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    732x
    2x

    2x

    3x
    5x

    3x

     import * as vscode from 'vscode';
    import commondir from 'commondir';

    export function getRootPath() {
      const absolutePathsOfWorkspaceFolders =
        vscode.workspace.workspaceFolders?.map(
          (workspaceFolder) => workspaceFolder.uri.fsPath
        ) || [];

      return commondir(absolutePathsOfWorkspaceFolders);
    }

    /*
    function getShortestCommonPath(paths: string[]): string | undefined {
      if (paths.length === 0) {
        return;
      }

      const firstPathChars = paths[0].split('');

      let shortestCommonPath: string = '';
      let temporaryChunk: string = '';

      for (let index = 0; index < firstPathChars.length; index++) {
        const char = firstPathChars[index];

        if (char === sep) {
          shortestCommonPath += temporaryChunk + char;
          temporaryChunk = '';
        } else if (isCharInAllPaths(char, index, paths)) {
          temporaryChunk += char;

          if(index === firstPathChars.length - 1) {

          }
        } else {
          console.log(char);
          break;
        }
      }

        return shortestCommonPath;
      const shortestCommonPath = firstPathChars.reduce(
        (acc, char, index) => {
          console.log(char);
          if (char === sep) {
            return {
              path: acc.path + acc.chunk + char,
              chunk: '',
            };
          } else if (isCharInAllPaths(char, index, paths)) {
            return {
              ...acc,
              chunk: acc.chunk + char,
            };
          }

          return {
            ...acc,
            chunk: '',
          };
        },
        { path: '', chunk: '' }
      ).path;

      return shortestCommonPath;
    }

    function isCharInAllPaths(char: string, index: number, paths: string[]) {
      return paths.every((path) => path.charAt(index) === char);
    }
    */