Skip to content
Snippets Groups Projects
Select Git revision
  • 89ed6773e76e18dcfddefdff01ba9d09e66c39fb
  • main default protected
  • release-0.15
  • automated-updates-main
  • release-0.13
  • automated-updates-release-0.13
  • release-0.14
  • release-0.10
  • release-0.11
  • release-0.12
  • fix-versions-action
  • versions-fix
  • release-0.9
  • release-0.8
  • release-0.7
  • release-0.6
  • release-0.5
  • release-0.4
  • release-0.3
  • release-0.1
  • release-0.2
  • v0.15.0
  • v0.14.0
  • v0.13.0
  • v0.12.0
  • v0.11.0
  • v0.10.0
  • v0.9.0
  • v0.8.0
  • v0.7.0
  • v0.6.0
  • v0.5.0
  • v0.4.0
  • v0.3.0
  • v0.2.0
  • v0.1.0
36 results

prometheus-frontend-svc.yaml

Blame
  • extract.ts 4.03 KiB
    import { logger } from '../../../logger';
    import { getSiblingFileName, localPathExists } from '../../../util/fs';
    import { newlineRegex, regEx } from '../../../util/regex';
    import { GitTagsDatasource } from '../../datasource/git-tags';
    import { GithubTagsDatasource } from '../../datasource/github-tags';
    import { GitlabTagsDatasource } from '../../datasource/gitlab-tags';
    import { PodDatasource } from '../../datasource/pod';
    import type { PackageDependency, PackageFile } from '../types';
    import type { ParsedLine } from './types';
    
    const regexMappings = [
      regEx(`^\\s*pod\\s+(['"])(?<spec>[^'"/]+)(\\/(?<subspec>[^'"]+))?(['"])`),
      regEx(
        `^\\s*pod\\s+(['"])[^'"]+(['"])\\s*,\\s*(['"])(?<currentValue>[^'"]+)(['"])\\s*$`
      ),
      regEx(`,\\s*:git\\s*=>\\s*(['"])(?<git>[^'"]+)(['"])`),
      regEx(`,\\s*:tag\\s*=>\\s*(['"])(?<tag>[^'"]+)(['"])`),
      regEx(`,\\s*:path\\s*=>\\s*(['"])(?<path>[^'"]+)(['"])`),
      regEx(`^\\s*source\\s*(['"])(?<source>[^'"]+)(['"])`),
    ];
    
    export function parseLine(line: string): ParsedLine {
      let result: ParsedLine = {};
      if (!line) {
        return result;
      }
      for (const regex of Object.values(regexMappings)) {
        const match = regex.exec(line.replace(regEx(/#.*$/), ''));
        if (match?.groups) {
          result = { ...result, ...match.groups };
        }
      }
    
      if (result.spec) {
        const depName = result.subspec
          ? `${result.spec}/${result.subspec}`
          : result.spec;
        const groupName = result.spec;
        if (depName) {
          result.depName = depName;
        }
        if (groupName) {
          result.groupName = groupName;
        }
        delete result.spec;
        delete result.subspec;
      }
    
      return result;
    }
    
    export function gitDep(parsedLine: ParsedLine): PackageDependency | null {
      const { depName, git, tag } = parsedLine;
    
      const platformMatch = regEx(
        /[@/](?<platform>github|gitlab)\.com[:/](?<account>[^/]+)\/(?<repo>[^/]+)/
      ).exec(git);
    
      if (platformMatch) {
        const { account, repo, platform } = platformMatch?.groups || {};
        if (account && repo) {
          const datasource =
            platform === 'github'
              ? GithubTagsDatasource.id
              : GitlabTagsDatasource.id;
          return {
            datasource,
            depName,
            packageName: `${account}/${repo.replace(regEx(/\.git$/), '')}`,
            currentValue: tag,
          };
        }
      }
    
      return {
        datasource: GitTagsDatasource.id,
        depName,
        packageName: git,
        currentValue: tag,
      };
    }
    
    export async function extractPackageFile(
      content: string,
      fileName: string
    ): Promise<PackageFile | null> {
      logger.trace('cocoapods.extractPackageFile()');
      const deps: PackageDependency[] = [];
      const lines: string[] = content.split(newlineRegex);
    
      const registryUrls: string[] = [];
    
      for (let lineNumber = 0; lineNumber < lines.length; lineNumber += 1) {
        const line = lines[lineNumber];
        const parsedLine = parseLine(line);
        const {
          depName,
          groupName,
          currentValue,
          git,
          tag,
          path,
          source,
        }: ParsedLine = parsedLine;
    
        if (source) {
          registryUrls.push(source.replace(regEx(/\/*$/), ''));
        }
    
        if (depName) {
          const managerData = { lineNumber };
          let dep: PackageDependency = {
            depName,
            groupName,
            skipReason: 'unknown-version',
          };
    
          if (currentValue) {
            dep = {
              depName,
              groupName,
              datasource: PodDatasource.id,
              currentValue,
              managerData,
              registryUrls,
            };
          } else if (git) {
            if (tag) {
              dep = { ...gitDep(parsedLine), managerData };
            } else {
              dep = {
                depName,
                groupName,
                skipReason: 'git-dependency',
              };
            }
          } else if (path) {
            dep = {
              depName,
              groupName,
              skipReason: 'path-dependency',
            };
          }
    
          deps.push(dep);
        }
      }
      const res: PackageFile = { deps };
      const lockFile = getSiblingFileName(fileName, 'Podfile.lock');
      // istanbul ignore if
      if (await localPathExists(lockFile)) {
        res.lockFiles = [lockFile];
      }
      return res;
    }