mirror of
https://github.com/dart-lang/sdk
synced 2024-09-15 23:39:48 +00:00
58392c017a
Change-Id: Iac4401d92f21fc1edd49e3abd9fc6c5474337cae Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/250769 Reviewed-by: Nate Bosch <nbosch@google.com> Commit-Queue: Devon Carew <devoncarew@google.com>
276 lines
8.6 KiB
Dart
276 lines
8.6 KiB
Dart
// Copyright (c) 2019, 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.
|
|
|
|
// Removes all status file expectations that are not relevant in the
|
|
// new workflow, but preserves entries with comments.
|
|
//
|
|
// For example, using the script on this status file
|
|
// a: Crash
|
|
// b: RuntimeError
|
|
// c: RuntimeError # Comment
|
|
// d: Pass, RuntimeError
|
|
// e: Pass, Slow, RuntimeError
|
|
// f: Pass, Slow, RuntimeError # Another comment
|
|
// will produce the output
|
|
// c: RuntimeError # Comment
|
|
// e: Slow
|
|
// f: Pass, Slow, RuntimeError # Another comment
|
|
//
|
|
// When using the option to keep crashes, there will be an additional line
|
|
// a: Crash
|
|
//
|
|
// The option -r can be used to also process expectations in lines with
|
|
// comments. In this mode, deleted comments are collected and either printed
|
|
// out or written to a separate file (with -w).
|
|
//
|
|
// The option -i (with -r) tries to resolve the status of issues mentioned in
|
|
// comments and adds it to the collected comments. This requires an issue.log
|
|
// file as described in [parseIssueFile].
|
|
|
|
import 'dart:io';
|
|
|
|
import 'package:args/args.dart';
|
|
import 'package:status_file/canonical_status_file.dart';
|
|
import 'package:status_file/expectation.dart';
|
|
import 'package:status_file/src/expression.dart';
|
|
|
|
StatusEntry? filterExpectations(
|
|
StatusEntry entry, List<Expectation> expectationsToKeep) {
|
|
List<Expectation> remaining = entry.expectations
|
|
.where(
|
|
(Expectation expectation) => expectationsToKeep.contains(expectation))
|
|
.toList();
|
|
return remaining.isEmpty
|
|
? null
|
|
: StatusEntry(entry.path, entry.lineNumber, remaining, entry.comment);
|
|
}
|
|
|
|
late Map<String, Map<int, String>> issues;
|
|
|
|
String getIssueState(String project, int issue) {
|
|
var projectIssues = issues[project];
|
|
if (projectIssues == null) {
|
|
throw "Cannot find project $project, not one of {${issues.keys.join(",")}}";
|
|
}
|
|
var state = projectIssues[issue] ?? "";
|
|
return "\t$state";
|
|
}
|
|
|
|
// This method assumes the following data format:
|
|
// <project>, <state>, <issue number>, <update timestamp>
|
|
// sorted by issue number then timestamp ascending.
|
|
//
|
|
// The first line is expected to contain the field names and is skipped.
|
|
Future<void> parseIssueFile() async {
|
|
issues = {};
|
|
String issuesLog = await File("issues.log").readAsString();
|
|
List<String> lines = issuesLog.split("\n");
|
|
for (String line in lines.skip(1).where((line) => line.isNotEmpty)) {
|
|
List<String> fields = line.split(",");
|
|
if (fields.length != 4) {
|
|
throw "invalid issue state line $line";
|
|
}
|
|
String project = fields[0];
|
|
String state = fields[1];
|
|
int issueNumber = int.parse(fields[2]);
|
|
issues.putIfAbsent(project, () => {})[issueNumber] = state;
|
|
}
|
|
}
|
|
|
|
List<RegExp> co19IssuePatterns = [
|
|
RegExp(r"https://github.com/dart-lang/co19/issues/(\d+)"),
|
|
RegExp(r"co19 issue (\d+)"),
|
|
];
|
|
|
|
List<RegExp> sdkIssuePatterns = [
|
|
RegExp(r"[Ii]ssue (\d+)"),
|
|
RegExp(r"#(\d+)"),
|
|
RegExp(r"^(\d+)$"),
|
|
RegExp(r"http://dartbug.com/(\d+)"),
|
|
RegExp(r"https://github.com/dart-lang/sdk/issues/(\d+)"),
|
|
];
|
|
|
|
String getIssueText(String comment, bool resolveState) {
|
|
int? issue;
|
|
late String prefix;
|
|
late String project;
|
|
for (var pattern in co19IssuePatterns) {
|
|
var match = pattern.firstMatch(comment);
|
|
if (match != null) {
|
|
issue = int.tryParse(match[1]!);
|
|
if (issue != null) {
|
|
prefix = "https://github.com/dart-lang/co19/issues/";
|
|
project = "dart-lang/co19";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (issue == null) {
|
|
for (var pattern in sdkIssuePatterns) {
|
|
var match = pattern.firstMatch(comment);
|
|
if (match != null) {
|
|
issue = int.tryParse(match[1]!);
|
|
if (issue != null) {
|
|
prefix = "https://dartbug.com/";
|
|
project = "dart-lang/sdk";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (issue != null) {
|
|
var state = resolveState ? getIssueState(project, issue) : "";
|
|
return "$prefix$issue$state";
|
|
} else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
Future<StatusFile> removeNonEssentialEntries(
|
|
StatusFile statusFile,
|
|
List<Expectation> expectationsToKeep,
|
|
bool removeComments,
|
|
List<String> comments,
|
|
bool resolveIssueState) async {
|
|
List<StatusSection> sections = <StatusSection>[];
|
|
for (StatusSection section in statusFile.sections) {
|
|
bool hasStatusEntries = false;
|
|
List<Entry> entries = <Entry>[];
|
|
for (Entry entry in section.entries) {
|
|
if (entry is EmptyEntry) {
|
|
entries.add(entry);
|
|
} else if (entry is CommentEntry) {
|
|
entries.add(entry);
|
|
hasStatusEntries = true;
|
|
} else if (entry is StatusEntry) {
|
|
StatusEntry? newEntry = entry;
|
|
if (entry.comment == null) {
|
|
newEntry = filterExpectations(entry, expectationsToKeep);
|
|
} else if (removeComments) {
|
|
newEntry = filterExpectations(entry, expectationsToKeep);
|
|
// Store comment if entry will be removed.
|
|
if (newEntry == null) {
|
|
String comment = entry.comment.toString().substring(1).trim();
|
|
String testName = entry.path;
|
|
String expectations = entry.expectations.toString();
|
|
// Remove '[' and ']'.
|
|
expectations = expectations.substring(1, expectations.length - 1);
|
|
String conditionPrefix = section.condition != Expression.always
|
|
? "${section.condition}"
|
|
: "";
|
|
String issueText = getIssueText(comment, resolveIssueState);
|
|
String statusLine = "$conditionPrefix\t$testName\t$expectations"
|
|
"\t$comment\t$issueText";
|
|
comments.add(statusLine);
|
|
}
|
|
}
|
|
if (newEntry != null) {
|
|
entries.add(newEntry);
|
|
hasStatusEntries = true;
|
|
}
|
|
} else {
|
|
throw "Unknown entry type ${entry.runtimeType}";
|
|
}
|
|
}
|
|
|
|
var isDefaultSection = section.condition == Expression.always;
|
|
if (hasStatusEntries ||
|
|
(isDefaultSection && section.sectionHeaderComments.isNotEmpty)) {
|
|
var newSection =
|
|
StatusSection(section.condition, -1, section.sectionHeaderComments);
|
|
newSection.entries.addAll(entries);
|
|
sections.add(newSection);
|
|
}
|
|
}
|
|
|
|
var newStatusFile = StatusFile(statusFile.path);
|
|
newStatusFile.sections.addAll(sections);
|
|
return newStatusFile;
|
|
}
|
|
|
|
ArgParser buildParser() {
|
|
var parser = ArgParser();
|
|
parser.addFlag("overwrite",
|
|
abbr: 'w',
|
|
negatable: false,
|
|
defaultsTo: false,
|
|
help: "Overwrite input file with output.");
|
|
parser.addFlag("keep-crashes",
|
|
abbr: 'c', negatable: false, defaultsTo: false);
|
|
parser.addFlag("remove-comments",
|
|
abbr: 'r', negatable: false, defaultsTo: false);
|
|
parser.addFlag("resolve-issue-states",
|
|
abbr: 'i', negatable: false, defaultsTo: false);
|
|
parser.addFlag("help",
|
|
abbr: "h",
|
|
negatable: false,
|
|
defaultsTo: false,
|
|
help: "Show help and commands for this tool.");
|
|
return parser;
|
|
}
|
|
|
|
void printHelp(ArgParser parser) {
|
|
print("Usage: dart pkg/status_file/bin/remove_non_essential_entries.dart"
|
|
" <path>");
|
|
print(parser.usage);
|
|
}
|
|
|
|
String formatComments(List<String> comments) {
|
|
StringBuffer sb = StringBuffer();
|
|
for (String statusLine in comments) {
|
|
sb.writeln(statusLine);
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
main(List<String> arguments) async {
|
|
var parser = buildParser();
|
|
var results = parser.parse(arguments);
|
|
if (results["help"] || results.rest.isEmpty) {
|
|
printHelp(parser);
|
|
return;
|
|
}
|
|
|
|
final List<Expectation> expectationsToKeep = <Expectation>[
|
|
Expectation.skip,
|
|
Expectation.skipByDesign,
|
|
Expectation.skipSlow,
|
|
Expectation.slow,
|
|
Expectation.extraSlow
|
|
];
|
|
|
|
if (results["keep-crashes"]) {
|
|
expectationsToKeep.add(Expectation.crash);
|
|
}
|
|
|
|
bool removeComments = results["remove-comments"];
|
|
|
|
for (String path in results.rest) {
|
|
List<String> comments = [];
|
|
|
|
bool writeFile = results["overwrite"];
|
|
bool resolveGithubIssueState = results["resolve-issue-states"];
|
|
var statusFile = StatusFile.read(path);
|
|
if (resolveGithubIssueState) {
|
|
await parseIssueFile();
|
|
}
|
|
statusFile = await removeNonEssentialEntries(statusFile, expectationsToKeep,
|
|
removeComments, comments, resolveGithubIssueState);
|
|
if (writeFile) {
|
|
await File(path).writeAsString(statusFile.toString());
|
|
print("Wrote $path.");
|
|
if (removeComments) {
|
|
await File("$path.csv").writeAsString(formatComments(comments));
|
|
print("Wrote $path.csv.");
|
|
}
|
|
} else {
|
|
print(statusFile);
|
|
if (removeComments) {
|
|
print("");
|
|
print(formatComments(comments));
|
|
}
|
|
}
|
|
}
|
|
}
|