pkgs/intl4x/test/tools/conformance_parser.dart

// Copyright (c) 2023, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:convert';
import 'dart:io';
import 'dart:math';

import 'package:args/args.dart';

void main(List<String> args) {
  final argParser = ArgParser();
  final referencePathOption = 'reference-path';
  final currentPathOption = 'current-path';
  argParser.addOption(
    referencePathOption,
    mandatory: true,
  );
  argParser.addOption(
    currentPathOption,
    mandatory: true,
  );
  final parse = argParser.parse(args);
  final pathToReference = parse[referencePathOption] as String;
  final pathToCurrent = parse[currentPathOption] as String;

  final infos = getInfos(getJson(pathToCurrent, 'dart_web'));
  final referenceInfos = getInfos(getJson(pathToReference, 'dart_web'));

  final markdown = StringBuffer('''
| Case | Total | Passing | Failing | Error | Unsupported |
| ---- | ----- | ------- | ------- | ----- | ----------- |
''');
  for (final entry in infos.entries) {
    final referenceInfo = referenceInfos[entry.key];
    markdown.writeln(
        '| ${entry.key} ${entry.value.getRow(referenceInfo ?? Info())}');
  }
  print(markdown);

  final errorMessage = compareToReference(infos, referenceInfos);
  if (errorMessage == null) {
    exit(0);
  } else {
    exit(1);
  }
}

String? compareToReference(
  Map<String, Info> infos,
  Map<String, Info> referenceInfos,
) {
  for (final entry in infos.entries) {
    final info = entry.value;
    final referenceInfo = referenceInfos[entry.key];
    if (referenceInfo != null) {
      final failureMessage = shouldFail(info, referenceInfo);
      if (failureMessage != null) {
        return failureMessage;
      }
    }
  }
  return null;
}

String? shouldFail(Info info, Info referenceInfo) {
  final moreErrors =
      info.error > referenceInfo.error ? 'Too many new errors' : null;
  final moreFailing =
      info.failing > referenceInfo.failing ? 'Too many new failing' : null;
  final moreUnsupported = info.unsupported > referenceInfo.unsupported
      ? 'Too many new unsupported'
      : null;
  return moreErrors ?? moreFailing ?? moreUnsupported;
}

Map<String, Info> getInfos(Map<String, dynamic> current) {
  final infos = <String, Info>{};
  for (final entry in current.entries) {
    final caseName = entry.key;
    final caseInfos = entry.value as List;
    final caseInfo = caseInfos.firstOrNull as Map<String, dynamic>?;
    if (caseInfo != null) {
      infos[caseName] = Info(
        total: caseInfo['test_count'] as int,
        error: caseInfo['error_count'] as int,
        failing: caseInfo['fail_count'] as int,
        passing: caseInfo['pass_count'] as int,
        unsupported: caseInfo['unsupported_count'] as int,
      );
    }
  }
  return infos;
}

Map<String, dynamic> getJson(String pathToCurrent, String exec) {
  final file = File(pathToCurrent);
  if (!file.existsSync()) return <String, dynamic>{};
  final currentStr = file.readAsStringSync();
  final decoded = jsonDecode(currentStr) as Map<String, dynamic>;

  return decoded.map((key, value) {
    final list = (value as List)
        .where((element) => (element as Map)['exec'] == exec)
        .toList();
    return MapEntry(key, list);
  });
}

class Info {
  final int total;
  final int passing;
  final int failing;
  final int error;
  final int unsupported;

  Info({
    this.total = 0,
    this.passing = 0,
    this.failing = 0,
    this.error = 0,
    this.unsupported = 0,
  });

  String getRow(Info reference) {
    final columnItems = [
      _getString(total, reference.total),
      _getString(passing, reference.passing),
      _getString(failing, reference.failing),
      _getString(error, reference.error),
      _getString(unsupported, reference.unsupported),
    ];
    return '| ${columnItems.join(' | ')} |';
  }

  String _getString(int current, int reference) {
    final change = (current - reference) / current;
    String changeStr;
    if (!change.isNaN) {
      final changePercent = change * 100;
      final changeClamped = max(min(changePercent, 100), -100);
      String prefix;
      if (changeClamped > 0) {
        prefix = ':arrow_upper_right:';
      } else if (changeClamped < 0) {
        prefix = ':arrow_lower_right:';
      } else {
        prefix = ':arrow_right:';
      }
      changeStr = '$prefix ${changeClamped.toStringAsFixed(2)} %';
    } else {
      changeStr = '';
    }
    final s = '$current $changeStr';
    return s;
  }
}