update build matrix step to use node

Author: ryanjbaxter

.github/workflows/run-github-actions-workflow-generator.yml

@@ -105,115 +105,116 @@ jobs:
           SPRING_RELEASE: ${{ inputs.spring-release }}
           PROJECTS_FILTER: ${{ inputs.projects }}
         run: |
-          python3 - << 'PYEOF'
-          import json, os, re, subprocess, sys
+          node - << 'JSEOF'
+          const { execFileSync } = require('child_process');
+          const fs = require('fs');
 
-          projects_json = subprocess.run(
-              ['gh', 'api', 'repos/spring-cloud/spring-cloud-github-actions/contents/config/projects.json',
-               '-X', 'GET', '-f', 'ref=main', '--jq', '.content'],
-              capture_output=True, text=True, check=True).stdout.strip()
-          decode = subprocess.run(['base64', '-d'], input=projects_json,
-                                  capture_output=True, text=True, check=True)
-          projects = json.loads(decode.stdout)
+          // Fetch projects.json from the main branch
+          const b64 = execFileSync('gh', [
+            'api', 'repos/spring-cloud/spring-cloud-github-actions/contents/config/projects.json',
+            '-X', 'GET', '-f', 'ref=main', '--jq', '.content'
+          ], { encoding: 'utf8' }).trim();
+          const projects = JSON.parse(Buffer.from(b64, 'base64').toString('utf8'));
 
-          defaults = projects.get('defaults', {})
+          const defaults = projects.defaults || {};
 
-          projects_filter_raw = os.environ.get('PROJECTS_FILTER', '').strip()
-          projects_filter = {p.strip() for p in projects_filter_raw.split(',') if p.strip()} if projects_filter_raw else set()
+          const projectsFilterRaw = (process.env.PROJECTS_FILTER || '').trim();
+          const projectsFilter = projectsFilterRaw
+            ? new Set(projectsFilterRaw.split(',').map(p => p.trim()).filter(Boolean))
+            : new Set();
 
-          def get_jdks(project_key, type_key, branch):
-              proj = projects.get(project_key, {})
-              type_cfg = proj.get(type_key, {})
-              jdkmap = type_cfg.get('jdkVersions', {})
-              if branch in jdkmap:
-                  return jdkmap[branch]
-              if 'default' in jdkmap:
-                  return jdkmap['default']
-              def_jdkmap = defaults.get(type_key, {}).get('jdkVersions', {})
-              if branch in def_jdkmap:
-                  return def_jdkmap[branch]
-              return def_jdkmap.get('default', ['17', '21', '25'])
+          function getJdks(projectKey, typeKey, branch) {
+            const typeCfg = (projects[projectKey] || {})[typeKey] || {};
+            const jdkmap = typeCfg.jdkVersions || {};
+            if (jdkmap[branch]) return jdkmap[branch];
+            if (jdkmap['default']) return jdkmap['default'];
+            const defJdkmap = (defaults[typeKey] || {}).jdkVersions || {};
+            if (defJdkmap[branch]) return defJdkmap[branch];
+            return defJdkmap['default'] || ['17', '21', '25'];
+          }
 
-          def primary_jdk(jdks):
-              return '8' if '8' in jdks else '17'
+          function primaryJdk(jdks) {
+            return jdks.includes('8') ? '8' : '17';
+          }
 
-          entries = []
-          seen = set()
+          const entries = [];
+          const seen = new Set();
 
-          def add_entry(repo, branch, type_key, project_key, jdk_lookup_branch=None):
-              key = (repo, branch)
-              if key in seen:
-                  return
-              seen.add(key)
-              jdks = get_jdks(project_key, type_key, jdk_lookup_branch or branch)
-              entries.append({
-                  'repo': repo,
-                  'branch': branch,
-                  'primary_jdk': primary_jdk(jdks),
-              })
+          function addEntry(repo, branch, typeKey, projectKey, jdkLookupBranch) {
+            const key = `${repo}@${branch}`;
+            if (seen.has(key)) return;
+            seen.add(key);
+            const jdks = getJdks(projectKey, typeKey, jdkLookupBranch || branch);
+            entries.push({ repo, branch, primary_jdk: primaryJdk(jdks) });
+          }
 
-          for project_key, config in projects.items():
-              if project_key == 'defaults':
-                  continue
-              if projects_filter and project_key not in projects_filter:
-                  continue
-              for type_key in ('oss', 'commercial'):
-                  type_cfg = config.get(type_key)
-                  if not type_cfg:
-                      continue
-                  repo = (f'spring-cloud/{project_key}-commercial'
-                          if type_key == 'commercial'
-                          else f'spring-cloud/{project_key}')
-                  for branch in type_cfg.get('branches', {}).get('scheduled', []):
-                      add_entry(repo, branch, type_key, project_key)
+          // Build entries from projects.json
+          for (const [projectKey, config] of Object.entries(projects)) {
+            if (projectKey === 'defaults') continue;
+            if (projectsFilter.size > 0 && !projectsFilter.has(projectKey)) continue;
+            for (const typeKey of ['oss', 'commercial']) {
+              const typeCfg = config[typeKey];
+              if (!typeCfg) continue;
+              const repo = typeKey === 'commercial'
+                ? `spring-cloud/${projectKey}-commercial`
+                : `spring-cloud/${projectKey}`;
+              for (const branch of (typeCfg.branches || {}).scheduled || []) {
+                addEntry(repo, branch, typeKey, projectKey);
+              }
+            }
+          }
 
-          spring_release = os.environ.get('SPRING_RELEASE', '').strip()
-          if spring_release:
-              result = subprocess.run(
-                  ['gh', 'api', 'repos/spring-io/release-train/contents/README.adoc',
-                   '-X', 'GET', '-f', f'ref={spring_release}', '--jq', '.content'],
-                  capture_output=True, text=True)
-              if result.returncode != 0:
-                  print(f'Warning: could not fetch README.adoc for spring release {spring_release}: '
-                        f'{result.stderr.strip()}', file=sys.stderr)
-              else:
-                  decode = subprocess.run(['base64', '-d'],
-                                          input=result.stdout.strip(),
-                                          capture_output=True, text=True)
-                  current_repo = None
-                  current_project_key = None
-                  for line in decode.stdout.splitlines():
-                      if re.match(r'^== ', line):
-                          if 'Spring Cloud' not in line:
-                              current_repo = None
-                              current_project_key = None
-                          continue
-                      m = re.search(
-                          r'\*\*Releasing from:\*\* https://github\.com/spring-cloud/([^\[]+)\[',
-                          line)
-                      if m:
-                          repo_name = m.group(1).strip().rstrip('/')
-                          current_repo = f'spring-cloud/{repo_name}'
-                          current_project_key = repo_name.replace('-commercial', '')
-                          continue
-                      if current_repo:
-                          vm = re.search(r'=== .+ (\d+\.\d+(?:\.\d+(?:\.\d+)?)?)\s*$', line)
-                          if vm:
-                              version = vm.group(1)
-                              parts = version.split('.')
-                              parent_branch = '.'.join(parts[:-1]) + '.x'
-                              if projects_filter and current_project_key not in projects_filter:
-                                  continue
-                              add_entry(current_repo, f'release/{version}',
-                                        'commercial', current_project_key,
-                                        jdk_lookup_branch=parent_branch)
+          // Optionally add release/[version] branches from the Spring release train README
+          const springRelease = (process.env.SPRING_RELEASE || '').trim();
+          if (springRelease) {
+            let readmeB64;
+            try {
+              readmeB64 = execFileSync('gh', [
+                'api', 'repos/spring-io/release-train/contents/README.adoc',
+                '-X', 'GET', '-f', `ref=${springRelease}`, '--jq', '.content'
+              ], { encoding: 'utf8' }).trim();
+            } catch (err) {
+              console.error(`Warning: could not fetch README.adoc for spring release ${springRelease}: ${err.message}`);
+            }
+            if (readmeB64) {
+              const content = Buffer.from(readmeB64, 'base64').toString('utf8');
+              let currentRepo = null;
+              let currentProjectKey = null;
+              for (const line of content.split('\n')) {
+                if (/^== /.test(line)) {
+                  if (!line.includes('Spring Cloud')) {
+                    currentRepo = null;
+                    currentProjectKey = null;
+                  }
+                  continue;
+                }
+                const releasingMatch = line.match(
+                  /\*\*Releasing from:\*\* https:\/\/github\.com\/spring-cloud\/([^\[]+)\[/
+                );
+                if (releasingMatch) {
+                  const repoName = releasingMatch[1].trim().replace(/\/$/, '');
+                  currentRepo = `spring-cloud/${repoName}`;
+                  currentProjectKey = repoName.replace(/-commercial$/, '');
+                  continue;
+                }
+                if (currentRepo) {
+                  const versionMatch = line.match(/=== .+ (\d+\.\d+(?:\.\d+(?:\.\d+)?)?)\s*$/);
+                  if (versionMatch) {
+                    const version = versionMatch[1];
+                    const parts = version.split('.');
+                    const parentBranch = parts.slice(0, -1).join('.') + '.x';
+                    if (projectsFilter.size > 0 && !projectsFilter.has(currentProjectKey)) continue;
+                    addEntry(currentRepo, `release/${version}`, 'commercial', currentProjectKey, parentBranch);
+                  }
+                }
+              }
+            }
+          }
 
-          matrix = {'include': entries}
-          matrix_json = json.dumps(matrix, separators=(',', ':'))
-          with open(os.environ['GITHUB_OUTPUT'], 'a') as f:
-              f.write(f'matrix={matrix_json}\n')
-          print(f'Matrix built: {len(entries)} entries')
-          PYEOF
+          const matrix = { include: entries };
+          fs.appendFileSync(process.env.GITHUB_OUTPUT, `matrix=${JSON.stringify(matrix)}\n`);
+          console.log(`Matrix built: ${entries.length} entries`);
+          JSEOF
 
   generate:
     name: "Generate — ${{ matrix.repo }}@${{ matrix.branch }}"