remove-liquid-statements.js

import { getLiquidConditionalsWithContent } from './get-liquid-conditionals.js'
import getVersionBlocks from './get-version-blocks.js'
import { allVersions } from '../../lib/all-versions.js'
import { Tokenizer } from 'liquidjs'
const supportedShortVersions = Object.values(allVersions).map((v) => v.shortName)
const updateRangeKeepGhes = 'updateRangeKeepGhes'
const updateRangeRemoveGhes = 'updateRangeRemoveGhes'
const removeRangeAndContent = 'removeRangeAndContent'
const removeConditionals = 'removeConditionals'

const tokenize = (str) => {
  const tokenizer = new Tokenizer(str)
  return tokenizer.readTopLevelTokens()
}
// This module is used by script/enterprise-server-deprecations/remove-version-markup.js to remove
// and update Liquid conditionals when a GHES release is being deprecated. It is also used by
// tests/content/remove-liquid-statements.js.
export default function removeLiquidStatements(content, release, nextOldestRelease, file) {
  let newContent = content

  // Get an array of ifversion blocks with their content included.
  const blocks = getLiquidConditionalsWithContent(newContent, 'ifversion')
  if (!blocks.length) return newContent

  // Decorate those blocks with more GHES versioning information.
  const versionBlocks = getVersionBlocks(blocks)

  // Determine whether we should remove the GHES range only or the GHES range and the content.
  for (const versionBlock of versionBlocks) {
    const actionMap = {}

    versionBlock.isGhesOnly = versionBlock.condArgs.every((arg) => arg.includes('ghes'))
    versionBlock.hasSingleRange = versionBlock.ranges.length === 1
    versionBlock.andGhesRanges = versionBlock.condArgs.filter((arg) => arg.includes('and ghes'))
    const isSafeToRemoveContent =
      versionBlock.isGhesOnly && (versionBlock.hasSingleRange || versionBlock.andGhesRanges.length)

    if (isConditionalNecessary(supportedShortVersions, versionBlock.condArgs)) {
      actionMap[removeConditionals] = true
    }

    for (const rangeArgs of versionBlock.ranges) {
      const rangeOperator = rangeArgs[1]
      const releaseNumber = rangeArgs[2]
      // We are only concerned with the release we are deprecating and the next oldest release..
      if (!(releaseNumber === release || releaseNumber === nextOldestRelease)) continue
      // But are not concerned with conditionals _equal_ to the next oldest release, as those are still valid.
      if (rangeOperator === '=' && releaseNumber === nextOldestRelease) continue

      // Remove Liquid in these scenarios.
      const greaterThanVersionToDeprecate = rangeOperator === '>' && releaseNumber === release
      const notEqualsVersionToDeprecate = rangeOperator === '!=' && releaseNumber === release

      // Remove Liquid and content in these scenarios, IF AND ONLY IF it's safe to remove content.
      // For example, when there is no other versioning in the conditional.
      const lessThanNextOldestVersion =
        rangeOperator === '<' && (releaseNumber === nextOldestRelease || releaseNumber === release)
      const equalsVersionToDeprecate = rangeOperator === '=' && releaseNumber === release

      let action

      // Determine which action to take: removeRangeAndContent, updateRangeRemoveGhes, updateRangeKeepGhes.
      if (greaterThanVersionToDeprecate || notEqualsVersionToDeprecate) {
        // If the original is `ghes > 2.21` or `fpt or ghes > 2.21`, we want to replace it with `ghes`;
        // If the original is `ghes > 2.21 and ghes < 3.0`, we want to remove the range and leave just `ghes < 3.0`.
        action = versionBlock.hasSingleRange ? updateRangeKeepGhes : updateRangeRemoveGhes
      }

      if (lessThanNextOldestVersion || equalsVersionToDeprecate) {
        // If it's not safe to remove content, we want to at least remove `ghes` from the range.
        action = isSafeToRemoveContent ? removeRangeAndContent : updateRangeRemoveGhes
      }

      if (action) {
        actionMap[action] = versionBlock.condArgs.find((arg) => arg.endsWith(rangeArgs.join(' ')))
      }
    }

    versionBlock.action = Object.keys(actionMap).length ? actionMap : 'none'
  }

  // Create the new content and add it to each block.
  versionBlocks
    .filter((versionBlock) => versionBlock.action !== 'none')
    .forEach((versionBlock) => {
      const indexOfLastEndif = lastIndexOfRegex(versionBlock.content, /{%-? endif -?%}/g)

      // ----- REMOVE RANGE AND CONTENT -----
      if (versionBlock.action.removeRangeAndContent) {
        // If the block has an else, remove the content up to the else, plus the final endif, leaving
        // the content inside the else block as is.
        if (versionBlock.hasElse) {
          // If the ifversion conditional starts at the beginning of a line
          // we can remove the newline after the else. If the if condition
          // doesn't start at the beginning of a new line, the content before
          // the ifversion tag will be concatenated to the content after the
          // else condition on a single line.
          const replaceRegex = versionBlock.startTagColumn1
            ? new RegExp(`${versionBlock.condWithLiquid}[\\S\\s]+?{%-? else -?%}\n?`)
            : new RegExp(`${versionBlock.condWithLiquid}[\\S\\s]+?{%-? else -?%}`)

          versionBlock.newContent = versionBlock.content
            .slice(0, indexOfLastEndif)
            .replace(replaceRegex, '')

          if (versionBlock.endTagColumn1 && versionBlock.newContent.endsWith('\n'))
            versionBlock.newContent = versionBlock.newContent.slice(0, -1)
        }

        // If the block has an elsif, remove the content up to the elsif, and change the elsif to an if (or leave it
        // an elsif this this block is itself an elsif), leaving the content inside the elsif block as is. The elsif
        // condition is evaluated separately so we don't need to worry about evaluating it here.
        if (versionBlock.hasElsif) {
          const replaceRegex = new RegExp(`${versionBlock.condWithLiquid}[\\S\\s]+?({%-?) elsif`)

          versionBlock.newContent = versionBlock.content.replace(
            replaceRegex,
            `$1 ${versionBlock.condKeyword}`
          )
        }

        // For all other scenarios, remove the Liquid and the content.
        if (!(versionBlock.hasElse || versionBlock.hasElsif)) {
          versionBlock.newContent = ''
        }
      }

      // ----- UPDATE RANGE AND REMOVE `GHES` -----
      if (versionBlock.action.updateRangeRemoveGhes) {
        // Make the replacement and get the new conditional.
        const newCondWithLiquid = versionBlock.condWithLiquid
          .replace(versionBlock.action.updateRangeRemoveGhes, '')
          .replace(/\s\s+/, ' ')

        // Update the conditional.
        versionBlock.newContent = versionBlock.content.replace(
          versionBlock.condWithLiquid,
          newCondWithLiquid
        )
      }

      // ----- UPDATE RANGE AND KEEP `GHES` -----
      let containsAllSupportedVersions
      if (versionBlock.action.updateRangeKeepGhes) {
        const replacement = versionBlock.action.updateRangeKeepGhes.replace(/ghes.+$/, 'ghes')

        // Make the replacement and get the new conditional.
        const newCondWithLiquid = versionBlock.condWithLiquid
          .replace(versionBlock.action.updateRangeKeepGhes, replacement)
          .replace(/\s\s+/, ' ')

        // If the new conditional contains all the currently supported versions, no conditional
        // is actually needed, and it can be removed. Any `else` statements and their content should
        // also be removed.
        containsAllSupportedVersions = isConditionalNecessary(
          supportedShortVersions,
          newCondWithLiquid
        )

        if (!containsAllSupportedVersions) {
          versionBlock.newContent = versionBlock.content.replace(
            versionBlock.condWithLiquid,
            newCondWithLiquid
          )
        }
      }

      // ----- REMOVE CONDITIONALS -----
      // this happens if either:
      // (a) the the conditional was updated in a previous step to contain all the currently supported versions, or
      // (b) the conditional was not touched but its arguments already contained all supported versions, making it unnecessary
      if (containsAllSupportedVersions || versionBlock.action.removeConditionals) {
        versionBlock.newContent = versionBlock.content

        // If this block does not contain else/elsifs, start by removing the final endif.
        // (We'll handle the endif separately in those scenarios.)
        if (!versionBlock.hasElse && !versionBlock.hasElsif) {
          const indexOfLastEndif = lastIndexOfRegex(versionBlock.content, /{%-? endif -?%}/g)

          versionBlock.newContent = versionBlock.newContent.slice(0, indexOfLastEndif)

          if (versionBlock.endTagColumn1 && versionBlock.newContent.endsWith('\n'))
            versionBlock.newContent = versionBlock.newContent.slice(0, -1)
        }

        // If start tag is on it's own line, remove line ending (\\n?)
        // and remove white space (//s*) after line ending to
        // preserve indentation of next line
        const removeStartTagRegex = versionBlock.startTagColumn1
          ? new RegExp(`${versionBlock.condWithLiquid}\\n?\\s*`)
          : new RegExp(`${versionBlock.condWithLiquid}`)

        // For ALL scenarios, remove the start tag.
        versionBlock.newContent = versionBlock.newContent.replace(removeStartTagRegex, '')

        // If the block has an elsif, change the elsif to an if (or leave it an elsif this this block is itself an elsif),
        // leaving the content inside the elsif block as is. Also leave the endif in this scenario.
        if (versionBlock.hasElsif) {
          versionBlock.newContent = versionBlock.newContent.replace(
            /({%-) elsif/,
            `$1 ${versionBlock.condKeyword}`
          )
        }

        // If the block has an else, remove the else, its content, and the endif.
        if (versionBlock.hasElse) {
          let elseStartIndex
          let ifCondFlag = false
          // tokenize the content including the nested conditionals to find
          // the unmatched else tag. Remove content from the start of the
          // else tag to the end of the content. The tokens return have different
          // `kind`s and can be liquid tags, HTML, and a variety of things.
          // A value of 4 is a liquid tag. See https://liquidjs.com/api/enums/parser_token_kind_.tokenkind.html.
          tokenize(versionBlock.newContent)
            .filter((elem) => elem.kind === 4)
            .forEach((tag) => {
              if (tag.name === 'ifversion' || tag.name === 'if') {
                ifCondFlag = true
              } else if (tag.name === 'endif' && ifCondFlag === true) {
                ifCondFlag = false
              } else if (tag.name === 'else' && ifCondFlag === false) {
                elseStartIndex = tag.begin
              }
            })
          versionBlock.newContent = versionBlock.newContent.slice(0, elseStartIndex)
        }
      }
    })

  // Now that we have the old and new content attached to each block, make the replacement
  // in the general content and return the updated general content.
  versionBlocks.forEach((versionBlock) => {
    if (versionBlock.action !== 'none') {
      const newBlockContent = versionBlock.newContent.replaceAll(/\n\n\n+?/g, '\n\n')

      newContent = newContent
        .replaceAll(versionBlock.content, newBlockContent)
        .replaceAll(/({%-? ifversion |{%-? elsif )(and|or) /g, '$1') // clean up stray and/ors :/
        .replaceAll(/\n\n\n+?/g, '\n\n')

      if (file && file.includes('/data/')) {
        newContent = newContent.trim()
      }
    }
  })

  return newContent
}

// Hack to use a regex with lastIndexOf.
// Inspired by https://stackoverflow.com/a/21420210
function lastIndexOfRegex(str, regex, fromIndex) {
  const myStr = fromIndex ? str.substring(0, fromIndex) : str
  const match = myStr.match(regex)

  return match ? myStr.lastIndexOf(match[match.length - 1]) : -1
}

// Checks if a conditional is necessary given all the supported versions and the arguments in a conditional
// If all supported versions show up in the arguments, it's not necessary! Additionally, builds in support
// for when feature-based versioning is used, which looks like "issue" versions for upcoming GHAE releases
function isConditionalNecessary(supportedVersions, conditionalArguments) {
  return supportedVersions.every(
    (arg) =>
      (conditionalArguments.includes(arg) || conditionalArguments.includes('or ' + arg)) &&
      !conditionalArguments.includes('issue')
  )
}