[release/9.x] Merge feature/9.x

.gitattributes

@@ -47,3 +47,13 @@
 ###############################################################################
 *.png				binary
 *.snk       		binary
+
+###############################################################################
+# Define branch specific files by overriding the merge driver
+###############################################################################
+global.json merge=ours
+eng/branch-vscode-config merge=ours
+eng/common merge=ours
+eng/Common.props merge=ours
+eng/Versions.props merge=ours
+eng/Version.Details.xml merge=ours

.github/actions/action-utils.js

@@ -51,4 +51,4 @@ module.exports.friendlyDateFromISODate = function(isoDate) {
 
 module.exports.splitVersionTag = splitVersionTag;
 module.exports.readFile = (fileName) => util.promisify(fs.readFile)(fileName, 'utf8');
-module.exports.writeFile = (fileName, contents) => util.promisify(fs.writeFile)(fileName, contents);
+module.exports.writeFile = (fileName, contents) => util.promisify(fs.writeFile)(fileName, contents);

.github/actions/generate-release-notes/index.js

@@ -155,6 +155,10 @@ async function generateChangelog(octokit, branch, repoOwner, repoName, minMergeD
         changelog.push(entry);
     }
 
+    if (changelog.length === 0) {
+        changelog.push("- Updated dependencies");
+    }
+
     return changelog.join("\n");
 }
 

.github/actions/learning-path-staleness-check/action.yml

@@ -0,0 +1,30 @@
+name: 'CheckLearningPathLinks Action'
+description: 'Checks the links in the learning paths for staleness'
+inputs:
+  repoURLToSearch:
+    description: 'The repo referenced in the learning path docs (in URL form)'
+    required: true
+  learningPathsDirectory:
+    description: 'The directory where the learning paths reside (e.g. documentation/learningPath)'
+    required: true
+  changedFilePaths:
+    description: 'Paths to the changed files'
+    required: false
+  sourceDirectoryName:
+    description: 'The name of the top-level directory (e.g. src) - only files inside this directory will be included in the search'
+    required: true
+  oldHash:
+    description: 'The hash currently being used by the learning path'
+    required: true
+  newHash:
+    description: 'The hash to be inserted into the updated learning path'
+    required: true
+  learningPathHashFile:
+    description: 'The file where the commit hash being used for the learning paths is kept'
+    required: true
+  excludeLinks:
+    description: 'Comma separated strings to exclude from processing'
+    required: false
+runs:
+  using: 'node16'
+  main: 'index.js'

.github/actions/learning-path-staleness-check/index.js

@@ -0,0 +1,274 @@
+const actionUtils = require('../action-utils.js');
+const fs = require('fs');
+const path = require('path');
+const prevPathPrefix = "prev/";
+const linePrefix = "#L";
+const separator = " | ";
+
+modifiedFilesPathToLearningPathFile = {};
+modifiedFilesUrlToFileName = {};
+
+var outOfSync = new Set();
+var manuallyReview = new Set();
+var suggestions = new Set();
+var modifiedFiles = new Set();
+
+const oldNewLinkSeparator = ' -> ';
+
+function ReplaceOldWithNewText(content, oldText, newText)
+{
+  return content.replaceAll(oldText, newText);
+}
+
+function UpdateModifiedFiles(fileName, path, learningPathFile)
+{
+  modifiedFilesUrlToFileName[path] = fileName;
+
+  modifiedFilesPathToLearningPathFile[path] = modifiedFilesPathToLearningPathFile[path] ? modifiedFilesPathToLearningPathFile[path] : new Set();;
+  modifiedFilesPathToLearningPathFile[path].add(learningPathFile);
+
+  modifiedFiles = new Set();
+  for (currPath in modifiedFilesPathToLearningPathFile)
+  {
+    const fileName = modifiedFilesUrlToFileName[currPath];
+    modifiedFiles.add(AssembleModifiedFilesOutput(fileName, currPath, Array.from(modifiedFilesPathToLearningPathFile[currPath])));
+  }
+}
+
+function AssembleModifiedFilesOutput(fileName, path, learningPathFiles)
+{
+  return CreateLink(fileName, path, undefined) + separator + BoldedText(learningPathFiles.join(" "));
+}
+
+function BoldedText(text)
+{
+  return "**" + text + "**";
+}
+
+function UpdateManuallyReview(fileName, path, learningPathFile, learningPathLineNumber, lineNumber = undefined)
+{
+  manuallyReview.add(AssembleOutput(fileName, path, undefined, lineNumber, undefined, learningPathFile, learningPathLineNumber))
+}
+
+function UpdateOutOfSync(link, learningPathFile)
+{
+  outOfSync.add(link + separator + BoldedText(learningPathFile))
+}
+
+function UpdateSuggestions(fileName, oldPath, newPath, learningPathFile, learningPathLineNumber, oldLineNumber, newLineNumber)
+{
+  suggestions.add(AssembleOutput(fileName, oldPath, newPath, oldLineNumber, newLineNumber, learningPathFile, learningPathLineNumber))
+}
+
+function CreateLink(fileName, path, lineNumber)
+{
+  var codeFileLink = "[" + fileName + "]" + "(" + path + ")"
+  return AppendLineNumber(codeFileLink, lineNumber)
+}
+
+function AssembleOutput(fileName, oldPath, newPath, oldLineNumber, newLineNumber, learningPathFile, learningPathLineNumber)
+{
+  var codeFileLink = CreateLink(fileName, oldPath, oldLineNumber)
+
+  if (newPath && newLineNumber) {
+    codeFileLink += oldNewLinkSeparator + CreateLink(fileName, newPath, newLineNumber)
+  }
+
+  return codeFileLink + separator + BoldedText(AppendLineNumber(learningPathFile, learningPathLineNumber, undefined));
+}
+
+function AppendLineNumber(text, lineNumber)
+{
+  if (!lineNumber) { return text }
+
+  return text + " " + linePrefix + lineNumber
+}
+
+function CheckForEndOfLink(str, startIndex)
+{
+  const illegalCharIndex = str.substr(startIndex).search(/[\>\])\s]|$|.$|.\s/m); // This regex isn't perfect, but should cover most cases.
+  return illegalCharIndex;
+}
+
+function StripLineNumber(link, linePrefixIndex)
+{
+  return link.substring(0, linePrefixIndex);
+}
+
+function GetContent(path) {
+  try {
+    return fs.readFileSync(path, 'utf8');
+  }
+  catch (error) {}
+
+  return undefined;
+}
+
+function ConstructOutputText(core)
+{
+  var body = "";
+
+  if (manuallyReview.size > 0) { body += "<h2>Manually Review:</h2>" + Array.from(manuallyReview).join("<br />") + "<br />"; }
+
+  if (outOfSync.size > 0) { body += "<h2>Links With Out Of Sync Commit Hashes:</h2>" + Array.from(outOfSync).join("<br />") + "<br />"; }
+
+  if (suggestions.size > 0) { body += "<h2>Auto-Applied Suggestions:</h2>" + Array.from(suggestions).join("<br />") + "<br />"; }
+
+  if (modifiedFiles.size > 0) { body += "<h2>Modified Files:</h2>" + Array.from(modifiedFiles).join("<br />") + "<br />"; }
+
+  console.log("body=" + body);
+  core.setOutput('outputText', body);
+}
+
+function ValidateLinks(learningPathContents, repoURLToSearch, modifiedPRFiles, learningPathFile, oldHash, newHash, sourceDirectoryName, excludeLinksArray)
+{
+  // Get all indices where a link to the repo is found within the current learning path file
+  var linkIndices = [];
+  for(var pos = learningPathContents.indexOf(repoURLToSearch); pos !== -1; pos = learningPathContents.indexOf(repoURLToSearch, pos + 1)) {
+      linkIndices.push(pos);
+  }
+
+  for(let startOfLink of linkIndices)
+  {
+    // Clean up the link, determine if it has a line number suffix
+    let endOfLink = startOfLink + CheckForEndOfLink(learningPathContents, startOfLink)
+    if (endOfLink < startOfLink) { endOfLink = learningPathContents.length; } // If no illegal characters are found, the link is at the end of the file
+
+    const link = learningPathContents.substring(startOfLink, endOfLink);
+
+    if (excludeLinksArray.some(excludeLink => link.toLowerCase().includes(excludeLink))) { continue; }
+
+    const pathStartIndex = link.indexOf(sourceDirectoryName);
+
+    if (pathStartIndex === -1) { continue }
+
+    if (!link.includes(oldHash))
+    {
+      UpdateOutOfSync(link, learningPathFile);
+      continue
+    }
+
+    const linePrefixIndex = link.indexOf(linePrefix);
+    const linkHasLineNumber = linePrefixIndex !== -1;
+    const pathEndIndex = linkHasLineNumber ? linePrefixIndex : endOfLink;
+
+    // Check if the file being referenced by the link is one of the modified files in the PR
+    const linkFilePath = link.substring(pathStartIndex, pathEndIndex);
+    if (modifiedPRFiles.includes(linkFilePath))
+    {
+      const fileName = linkFilePath.substring(linkFilePath.lastIndexOf('/') + 1);
+
+      UpdateModifiedFiles(fileName, linkHasLineNumber ? StripLineNumber(link, linePrefixIndex) : link, learningPathFile);
+
+      // This is the line number in the learning path file that contains the link - not the #L line number in the link itself
+      const learningPathLineNumber = learningPathContents.substring(0, startOfLink).split("\n").length;
+
+      var headContent = GetContent(linkFilePath)
+      if (!headContent) {
+        UpdateManuallyReview(fileName, link, learningPathFile, learningPathLineNumber);
+        continue
+      }
+      const headContentLines = headContent.toString().split("\n");
+
+      if (!linkHasLineNumber) { continue; }
+      const oldLineNumber = Number(link.substring(linePrefixIndex + linePrefix.length, link.length));
+
+      var prevContent = GetContent(prevPathPrefix + linkFilePath)
+      if (!prevContent) { continue; }
+      const prevContentLines = prevContent.toString().split("\n");
+
+      if (prevContentLines.length < oldLineNumber)
+      {
+        UpdateManuallyReview(fileName, link, learningPathFile, learningPathLineNumber, oldLineNumber);
+      }
+      else if (headContentLines.length < oldLineNumber || prevContentLines[oldLineNumber - 1].trim() !== headContentLines[oldLineNumber - 1].trim())
+      {
+        const newLineNumberLast = headContentLines.lastIndexOf(prevContentLines[oldLineNumber - 1]) + 1;
+        const newLineNumberFirst = headContentLines.indexOf(prevContentLines[oldLineNumber - 1]) + 1;
+
+        if (newLineNumberLast !== newLineNumberFirst) // Multiple matches found in the file
+        {
+          UpdateManuallyReview(fileName, link, learningPathFile, learningPathLineNumber, oldLineNumber);
+        }
+        else
+        {
+          let updatedLink = StripLineNumber(link.replace(oldHash, newHash), linePrefixIndex) + linePrefix + newLineNumberFirst;
+          UpdateSuggestions(fileName, link, updatedLink, learningPathFile, learningPathLineNumber, oldLineNumber, newLineNumberFirst);
+        }
+      }
+    }
+  }
+}
+
+const main = async () => {
+
+  const [core] = await actionUtils.installAndRequirePackages("@actions/core");
+
+  try {
+    const learningPathDirectory = core.getInput('learningPathsDirectory', { required: true });
+    const repoURLToSearch = core.getInput('repoURLToSearch', { required: true });
+    const changedFilePaths = core.getInput('changedFilePaths', {required: false});
+    const learningPathHashFile = core.getInput('learningPathHashFile', { required: true });
+    const sourceDirectoryName = core.getInput('sourceDirectoryName', { required: true });
+    const oldHash = core.getInput('oldHash', { required: true });
+    const newHash = core.getInput('newHash', { required: true });
+    const excludeLinks = core.getInput('excludeLinks', { required: false });
+    const excludeLinksArray = excludeLinks ? excludeLinks.split(',').map(function(item) { return item.toLowerCase().trim() }) : [];
+
+    if (changedFilePaths === null || changedFilePaths.trim() === "") { return }
+
+    // Scan each file in the learningPaths directory
+    fs.readdir(learningPathDirectory, (_, files) => {
+      files.forEach(learningPathFile => {
+        try {
+          const learningPathContents = GetContent(path.join(learningPathDirectory, learningPathFile))
+          if (learningPathContents)
+          {
+            ValidateLinks(learningPathContents, repoURLToSearch, changedFilePaths.split(' '), learningPathFile, oldHash, newHash, sourceDirectoryName, excludeLinksArray)
+            ConstructOutputText(core);
+          }
+        } catch (error) {
+          console.log("Error: " + error)
+          console.log("Could not find learning path file: " + learningPathFile)
+        }
+      });
+    });
+
+    fs.writeFileSync(learningPathHashFile, newHash);
+
+    // Scan each file in the learningPaths directory
+    fs.readdir(learningPathDirectory, (_, files) => {
+
+      files.forEach(learningPathFile => {
+        try {
+          const fullPath = path.join(learningPathDirectory, learningPathFile)
+          let content = fs.readFileSync(fullPath, 'utf8')
+
+          let suggestionsArray = Array.from(suggestions);
+          if (suggestionsArray && suggestionsArray.length > 0) {
+            suggestionsArray.forEach(suggestion => {
+              const suggestionArray = suggestion.split(oldNewLinkSeparator)
+              var oldLink = suggestionArray[0]
+              var newLink = suggestionArray[1]
+              oldLink = oldLink.substring(oldLink.indexOf('(') + 1, oldLink.lastIndexOf(')'))
+              newLink = newLink.substring(newLink.indexOf('(') + 1, newLink.lastIndexOf(')'))
+              content = ReplaceOldWithNewText(content, oldLink, newLink)
+            })
+          }
+
+          content = ReplaceOldWithNewText(content, oldHash, newHash)
+          fs.writeFileSync(fullPath, content);
+        } catch (error) {
+          console.log("Error: " + error)
+          console.log("Could not find learning path file: " + learningPathFile)
+        }
+      });
+    });
+
+  } catch (error) {
+    core.setFailed(error.message);
+  }
+}
+
+// Call the main function to run the action
+main();

.github/actions/open-pr/action.yml

@@ -25,6 +25,9 @@ inputs:
   fail_if_files_unchanged:
     description: 'Fails the action if all of the specified files_to_commit are unchanged.'
     required: false
+  always_create_pr:
+    description: 'Always try to create a PR, even if there are no uncommitted changes.'
+    required: false
   update_if_already_exists:
     description: 'Allows updating an existing PR, or re-opening it if closed.'
     required: false
@@ -49,8 +52,8 @@ runs:
 
         base_branch_name=${BASE_BRANCH_NAME:-${current_branch_name}}
 
-        git config user.name "github-actions"
-        git config user.email "github-actions@github.com"
+        git config user.name "github-actions[bot]"
+        git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
         git add ${{ inputs.files_to_commit }}
 
         are_files_changed=""
@@ -61,10 +64,13 @@ runs:
             exit 1
           fi
 
-          exit 0
+          if [[ "$ALWAYS_CREATE_PR" != "true" ]]; then
+            exit 0
+          fi
+        else
+          git commit -m "$COMMIT_MESSAGE"
         fi
 
-        git commit -m "$COMMIT_MESSAGE"
         git push --force --set-upstream origin "HEAD:$pr_branch_name"
 
         extraArgs=""
@@ -81,6 +87,7 @@ runs:
         COMMIT_MESSAGE: ${{ inputs.commit_message }}
         DRAFT: ${{ inputs.draft }}
         LABELS: ${{ inputs.labels }}
+        ALWAYS_CREATE_PR: ${{ inputs.always_create_pr }}
         FAIL_IF_FILES_UNCHANGED: ${{ inputs.fail_if_files_unchanged }}
         UPDATE_IF_ALREADY_EXISTS: ${{ inputs.update_if_already_exists }}
         TITLE: ${{ inputs.title }}