Search OSD for certain strings in certain files

search.js

/*
 * Copyright OpenSearch Contributors
 * SPDX-License-Identifier: Apache-2.0
 */

const fs = require('fs');
const path = require('path');

const searchTerms = ['font family', 'font size', 'font weight', 'font style', 'line height']
  .map((term) => term.split(' '))
  .map((terms) => terms.map((term) => term.toLowerCase()))
  .map((terms) => [
    terms.join('-'),
    terms.join('_'),
    `${terms[0]}${terms.slice(1).map((term) => `${term[0].toUpperCase()}${term.slice(1)}`)}`,
  ])
  .flat();

const additionalTerms = ['euiFont', 'euiCodeFont'];

const regex = new RegExp([...searchTerms, ...additionalTerms].join('|'), 'gm');

const includePaths = ['packages', 'src'].map((filterPath) => path.join(__dirname, filterPath));

function getTargetPaths(rootPath) {
  const dirs = fs.readdirSync(rootPath);
  const targetPaths = [];

  for (const dir of dirs) {
    targetPaths.push(path.join(rootPath, dir, 'target'));
  }

  return targetPaths;
}

const ignorePaths = [
  path.join(__dirname, 'packages/osd-ui-framework'),
  ...getTargetPaths(path.join(__dirname, 'src', 'plugins')),
  ...getTargetPaths(path.join(__dirname, 'packages')),
];

const ignoreExtensions = ['.map'];

function recursePath(currentDir, callback) {
  const files = fs.readdirSync(currentDir);

  for (const file of files) {
    const filePath = path.join(currentDir, file);
    const stat = fs.lstatSync(filePath);

    if (includePaths.map((includePath) => filePath.startsWith(includePath)).filter(Boolean) < 1) {
      continue;
    }

    if (
      ignorePaths.map((ignorePath) => filePath.startsWith(ignorePath)).filter(Boolean).length > 0
    ) {
      continue;
    }

    if (
      ignoreExtensions.map((ignoreExtension) => filePath.endsWith(ignoreExtension)).filter(Boolean)
        .length > 0
    ) {
      continue;
    }

    if (stat.isFile()) {
      callback(filePath);
    } else if (stat.isDirectory()) {
      recursePath(filePath, callback);
    }
  }
}

const matches = {};

recursePath(__dirname, function search(searchPath) {
  let contents;
  try {
    contents = fs.readFileSync(searchPath).toString();
  } catch (e) {
    console.error(`failed to read ${searchPath}`);
    return;
  }

  let match;
  while ((match = regex.exec(contents)) !== null) {
    // Prevent infinite loops on zero-width matches
    if (match.index === regex.lastIndex) {
      regex.lastIndex++;
    }

    const lineNumber =
      contents
        .slice(0, match.index)
        .split('')
        .filter((c) => c === '\n').length + 1;

    (matches[searchPath] || (matches[searchPath] = [])).push([match[0], lineNumber]);
  }
});

const sortedMatches = Object.entries(matches).map(([matchPath, matchStrings]) => [
  matchPath.slice(__dirname.length + 1),
  matchStrings,
]);

for (const [, matches] of sortedMatches) {
  matches.sort(([, aLineNumber], [, bLineNumber]) => {
    return aLineNumber - bLineNumber;
  });
}

sortedMatches.sort(([a], [b]) => {
  const aSplit = a.split('.');
  const aExt = aSplit[aSplit.length - 1];

  const bSplit = b.split('.');
  const bExt = bSplit[bSplit.length - 1];

  return aExt.localeCompare(bExt);
});

console.log('| file name | matched strings |');
console.log('| --- | --- |');

for (const [matchPath, matchStrings] of sortedMatches) {
  console.log(
    `| [\`${matchPath}\`](https://github.com/opensearch-project/OpenSearch-Dashboards/blob/main/${matchPath}) | ${matchStrings
      .map(
        ([match, ln]) =>
          `[\`${match}\`](https://github.com/opensearch-project/OpenSearch-Dashboards/blob/cb273364086057b542a55d2bbe28631313a22df9/${matchPath}#L${ln})`
      )
      .join(', ')} |`
  );
}