task-utils.js

// helper functions to use from "task.js" plugins code
// that need access to the file system

// @ts-check
/// <reference types="cypress" />
const { readFileSync, writeFileSync, existsSync } = require('fs')
const { isAbsolute, resolve, join } = require('path')
const debug = require('debug')('code-coverage')
const chalk = require('chalk')
const globby = require('globby')
const yaml = require('js-yaml')
const {
  combineNycOptions,
  defaultNycOptions,
  fileCoveragePlaceholder,
} = require('./common-utils')

function readNycOptions(workingDirectory) {
  const pkgFilename = join(workingDirectory, 'package.json')
  const pkg = existsSync(pkgFilename)
    ? JSON.parse(readFileSync(pkgFilename, 'utf8'))
    : {}
  const pkgNycOptions = pkg.nyc || {}

  const nycrcFilename = join(workingDirectory, '.nycrc')
  const nycrc = existsSync(nycrcFilename)
    ? JSON.parse(readFileSync(nycrcFilename, 'utf8'))
    : {}

  const nycrcJsonFilename = join(workingDirectory, '.nycrc.json')
  const nycrcJson = existsSync(nycrcJsonFilename)
    ? JSON.parse(readFileSync(nycrcJsonFilename, 'utf8'))
    : {}

  const nycrcYamlFilename = join(workingDirectory, '.nycrc.yaml')
  let nycrcYaml = {}
  if (existsSync(nycrcYamlFilename)) {
    try {
      nycrcYaml = yaml.safeLoad(readFileSync(nycrcYamlFilename, 'utf8'))
    } catch (error) {
      throw new Error(`Failed to load .nycrc.yaml: ${error.message}`)
    }
  }

  const nycrcYmlFilename = join(workingDirectory, '.nycrc.yml')
  let nycrcYml = {}
  if (existsSync(nycrcYmlFilename)) {
    try {
      nycrcYml = yaml.safeLoad(readFileSync(nycrcYmlFilename, 'utf8'))
    } catch (error) {
      throw new Error(`Failed to load .nycrc.yml: ${error.message}`)
    }
  }

  const nycConfigFilename = join(workingDirectory, 'nyc.config.js')
  let nycConfig = {}
  if (existsSync(nycConfigFilename)) {
    try {
      nycConfig = require(nycConfigFilename)
    } catch (error) {
      throw new Error(`Failed to load nyc.config.js: ${error.message}`)
    }
  }

  const nycOptions = combineNycOptions(
    defaultNycOptions,
    nycrc,
    nycrcJson,
    nycrcYaml,
    nycrcYml,
    nycConfig,
    pkgNycOptions,
  )
  debug('combined NYC options %o', nycOptions)

  return nycOptions
}

function getNycOptions(workingDirectory) {
  if (!workingDirectory) {
    workingDirectory = process.cwd()
  }

  // https://github.com/istanbuljs/nyc#common-configuration-options
  const nycReportOptions = readNycOptions(workingDirectory)

  if (nycReportOptions.exclude && !Array.isArray(nycReportOptions.exclude)) {
    console.error('NYC options: %o', nycReportOptions)
    throw new Error('Expected "exclude" to by an array')
  }

  if (nycReportOptions['temp-dir']) {
    nycReportOptions['temp-dir'] = resolve(nycReportOptions['temp-dir'])
  } else {
    nycReportOptions['temp-dir'] = join(workingDirectory, '.nyc_output')
  }

  nycReportOptions.tempDir = nycReportOptions['temp-dir']

  if (nycReportOptions['report-dir']) {
    nycReportOptions['report-dir'] = resolve(nycReportOptions['report-dir'])
  }
  // seems nyc API really is using camel cased version
  nycReportOptions.reportDir = nycReportOptions['report-dir']

  return nycReportOptions
}

function getNycReportFilename(workingDirectory) {
  const nycReportOptions = getNycOptions(workingDirectory)

  const nycFilename = join(nycReportOptions['temp-dir'], 'out.json')
  return nycFilename
}

function checkAllPathsNotFound(nycFilename) {
  const nycCoverage = JSON.parse(readFileSync(nycFilename, 'utf8'))

  const coverageKeys = Object.keys(nycCoverage)
  if (!coverageKeys.length) {
    debug('⚠️ file %s has no coverage information', nycFilename)
    return
  }

  const allFilesAreMissing = coverageKeys.every((key, k) => {
    const coverage = nycCoverage[key]
    return !existsSync(coverage.path)
  })

  debug(
    'in file %s all files are not found? %o',
    nycFilename,
    allFilesAreMissing,
  )
  return allFilesAreMissing
}

/**
 * A small debug utility to inspect paths saved in NYC output JSON file
 */
function showNycInfo(nycFilename) {
  const nycCoverage = JSON.parse(readFileSync(nycFilename, 'utf8'))

  const coverageKeys = Object.keys(nycCoverage)
  if (!coverageKeys.length) {
    console.error(
      '⚠️ file %s has no coverage information',
      chalk.yellow(nycFilename),
    )
    console.error(
      'Did you forget to instrument your web application? Read %s',
      chalk.blue(
        'https://github.com/cypress-io/code-coverage#instrument-your-application',
      ),
    )
    return
  }
  debug('NYC file %s has %d key(s)', nycFilename, coverageKeys.length)

  const maxPrintKeys = 3
  const showKeys = coverageKeys.slice(0, maxPrintKeys)

  showKeys.forEach((key, k) => {
    const coverage = nycCoverage[key]

    // printing a few found keys and file paths from the coverage file
    // will make debugging any problems much much easier
    if (k < maxPrintKeys) {
      debug('%d key %s file path %s', k + 1, key, coverage.path)
    }
  })
}

/**
 * Looks at all coverage objects in the given JSON coverage file
 * and if the file is relative, and exists, changes its path to
 * be absolute.
 */
function resolveRelativePaths(nycFilename) {
  const nycCoverage = JSON.parse(readFileSync(nycFilename, 'utf8'))

  const coverageKeys = Object.keys(nycCoverage)
  if (!coverageKeys.length) {
    debug('⚠️ file %s has no coverage information', nycFilename)
    return
  }
  debug('NYC file %s has %d key(s)', nycFilename, coverageKeys.length)

  let changed

  coverageKeys.forEach((key, k) => {
    const coverage = nycCoverage[key]

    if (!coverage.path) {
      debug('key %s does not have path', key)
      return
    }

    if (!isAbsolute(coverage.path)) {
      if (existsSync(coverage.path)) {
        debug('resolving path %s', coverage.path)
        coverage.path = resolve(coverage.path)
        changed = true
      }
      return
    }

    // path is absolute, let's check if it exists
    if (!existsSync(coverage.path)) {
      debug('⚠️ cannot find file %s with hash %s', coverage.path, coverage.hash)
    }
  })

  if (changed) {
    debug('resolveRelativePaths saving updated file %s', nycFilename)
    debug('there are %d keys in the file', coverageKeys.length)
    writeFileSync(
      nycFilename,
      JSON.stringify(nycCoverage, null, 2) + '\n',
      'utf8',
    )
  }
}

/**
 * @param {string[]} filepaths
 * @returns {string | undefined} common prefix that corresponds to current folder
 */
function findCommonRoot(filepaths) {
  if (!filepaths.length) {
    debug('cannot find common root without any files')
    return
  }

  // assuming / as file separator
  const splitParts = filepaths.map((name) => name.split('/'))
  const lengths = splitParts.map((arr) => arr.length)
  const shortestLength = Math.min.apply(null, lengths)
  debug('shorted file path has %d parts', shortestLength)

  const cwd = process.cwd()
  let commonPrefix = []
  let foundCurrentFolder

  for (let k = 0; k < shortestLength; k += 1) {
    const part = splitParts[0][k]
    const prefix = commonPrefix.concat(part).join('/')
    debug('testing prefix %o', prefix)
    const allFilesStart = filepaths.every((name) => name.startsWith(prefix))
    if (!allFilesStart) {
      debug('stopped at non-common prefix %s', prefix)
      break
    }

    commonPrefix.push(part)

    const removedPrefixNames = filepaths.map((filepath) =>
      filepath.slice(prefix.length),
    )
    debug('removedPrefix %o', removedPrefixNames)

    let foundCount = 0
    removedPrefixNames.forEach((filepath) => {
      if (existsSync(join(cwd, filepath))) {
        foundCount += 1
      }
    })
    const foundMostPaths = foundCount >= removedPrefixNames.length / 2
    debug('found %d files out of %d', foundCount, removedPrefixNames.length)
    debug('found most files found at "%s"? %o', prefix, foundMostPaths)
    if (foundMostPaths) {
      foundCurrentFolder = prefix
      debug(
        'found prefix that matches current folder: "%s"',
        foundCurrentFolder,
      )
      break
    }
  }

  return foundCurrentFolder
}

function tryFindingLocalFiles(nycFilename) {
  const nycCoverage = JSON.parse(readFileSync(nycFilename, 'utf8'))
  const coverageKeys = Object.keys(nycCoverage)
  const filenames = coverageKeys.map((key) => nycCoverage[key].path)
  const commonFolder = findCommonRoot(filenames)
  if (commonFolder === undefined) {
    debug('could not find common folder %s', commonFolder)
    return
  }
  const cwd = process.cwd()
  debug(
    'found common folder %s that matches current working directory %s',
    commonFolder,
    cwd,
  )
  let changed

  if (commonFolder === '') {
    // we just need to prefix the paths with the current folder
    coverageKeys.forEach((key) => {
      const filePath = nycCoverage[key].path
      const to = join(cwd, filePath)
      // ? Do we need to replace the "key" in the coverage object or can we just replace the "path"?
      nycCoverage[key].path = to
      debug('formed %s -> %s', filePath, to)
      changed = true
    })
  } else {
    // we need to replace part of the paths with the current folder
    const length = commonFolder.length
    coverageKeys.forEach((key) => {
      const from = nycCoverage[key].path
      if (from.startsWith(commonFolder)) {
        const to = join(cwd, from.slice(length))
        // ? Do we need to replace the "key" in the coverage object or can we just replace the "path"?
        nycCoverage[key].path = to
        debug('replaced %s -> %s', from, to)
        changed = true
      }
    })
  }

  if (changed) {
    debug('tryFindingLocalFiles saving updated file %s', nycFilename)
    debug('there are %d keys in the file', coverageKeys.length)
    writeFileSync(
      nycFilename,
      JSON.stringify(nycCoverage, null, 2) + '\n',
      'utf8',
    )
  }
}

/**
 * Tries to find source files to be included in the final coverage report
 * using NYC options: extension list, include and exclude.
 */
function findSourceFiles(nycOptions) {
  debug('include all files options: %o', {
    all: nycOptions.all,
    include: nycOptions.include,
    exclude: nycOptions.exclude,
    extension: nycOptions.extension,
  })

  if (!Array.isArray(nycOptions.extension)) {
    console.error(
      'Expected NYC "extension" option to be a list of file extensions',
    )
    console.error(nycOptions)
    return []
  }

  let patterns = []
  if (Array.isArray(nycOptions.include)) {
    patterns = patterns.concat(nycOptions.include)
  } else if (typeof nycOptions.include === 'string') {
    patterns.push(nycOptions.include)
  } else {
    debug('using default list of extensions')
    nycOptions.extension.forEach((extension) => {
      patterns.push('**/*' + extension)
    })
  }

  if (Array.isArray(nycOptions.exclude)) {
    const negated = nycOptions.exclude.map((s) => '!' + s)
    patterns = patterns.concat(negated)
  } else if (typeof nycOptions.exclude === 'string') {
    patterns.push('!' + nycOptions.exclude)
  }
  // always exclude node_modules
  // https://github.com/istanbuljs/nyc#including-files-within-node_modules
  patterns.push('!**/node_modules/**')
  // and exclude the Cypress config file
  patterns.push('!cypress.config.*')

  debug('searching files to include using patterns %o', patterns)

  const allFiles = globby.sync(patterns, { absolute: true })
  return allFiles
}
/**
 * If the website or unit tests did not load ALL files we need to
 * include, then we should include the missing files ourselves
 * before generating the report.
 *
 * @see https://github.com/cypress-io/code-coverage/issues/207
 */
function includeAllFiles(nycFilename, nycOptions) {
  if (!nycOptions.all) {
    debug('NYC "all" option is not set, skipping including all files')
    return
  }

  const allFiles = findSourceFiles(nycOptions)
  if (debug.enabled) {
    debug('found %d file(s)', allFiles.length)
    console.error(allFiles.join('\n'))
  }
  if (!allFiles.length) {
    debug('no files found, hoping for the best')
    return
  }

  const nycCoverage = JSON.parse(readFileSync(nycFilename, 'utf8'))
  const coverageKeys = Object.keys(nycCoverage)
  const coveredPaths = coverageKeys.map((key) =>
    nycCoverage[key].path.replace(/\\/g, '/'),
  )

  debug('coverage has %d record(s)', coveredPaths.length)
  // report on first couple of entries
  if (debug.enabled) {
    console.error('coverage has the following first paths')
    console.error(coveredPaths.slice(0, 4).join('\n'))
  }

  let changed
  allFiles.forEach((fullPath) => {
    if (coveredPaths.includes(fullPath)) {
      // all good, this file exists in coverage object
      return
    }
    debug('adding empty coverage for file %s', fullPath)
    changed = true
    // insert placeholder object for now
    const placeholder = fileCoveragePlaceholder(fullPath)
    nycCoverage[fullPath] = placeholder
  })

  if (changed) {
    debug('includeAllFiles saving updated file %s', nycFilename)
    debug('there are %d keys in the file', Object.keys(nycCoverage).length)

    writeFileSync(
      nycFilename,
      JSON.stringify(nycCoverage, null, 2) + '\n',
      'utf8',
    )
  }
}

function getCoverage() {
  const jsonFilename = join('.', '.nyc_output', 'out.json')
  const json = JSON.parse(readFileSync(jsonFilename, 'utf8'))
  return json
}

function updateSpecCovers(specName, specCovers) {
  const jsonFilename = join('.', '.nyc_output', 'spec-covers.json')
  const json = existsSync(jsonFilename)
    ? JSON.parse(readFileSync(jsonFilename, 'utf8'))
    : {}
  json[specName] = specCovers
  const text = JSON.stringify(json, null, 2) + '\n'
  writeFileSync(jsonFilename, text, 'utf8')
  return json
}

module.exports = {
  showNycInfo,
  resolveRelativePaths,
  checkAllPathsNotFound,
  tryFindingLocalFiles,
  readNycOptions,
  getNycOptions,
  getNycReportFilename,
  includeAllFiles,
  getCoverage,
  updateSpecCovers,
}