dangerfile.ts

export default async (): undefined => {
  if (danger.github.pr.labels.length > 0) {
    fail("PR is not allowed to have labels");
    return;
  }

  if (danger.github.pr.milestone) {
    fail("PR is not allowed to have milestone");
    return;
  }

  if (danger.github.pr.assignee?.id !== danger.github.pr.user.id) {
    fail("Only PR author could be assigned to PR");
    return;
  }

  const commitTest = danger.git.commits.map((commit) =>
    commit.message.match(/^(\w+):/),
  );

  if (!commitTest.every((match) => match)) {
    fail("Unable to analyze commit types");
    return;
  }

  const commitTypes = new Set(commitTest.map((commitMatch) => commitMatch[1])),
    hasFeatureCommit = commitTypes.has("feat"),
    hasFixCommit = commitTypes.has("fix"),
    hasDocsCommit = commitTypes.has("docs"),
    hasTestCommit = commitTypes.has("test");

  const hasBreakingCommit = danger.git.commits
    .map((commit) => commit.message.match(/\sBREAKING CHANGE:\s/g))
    .some((match) => match);

  const commitFiles = danger.git.created_files
      .concat(danger.git.modified_files)
      .concat(danger.git.deleted_files),
    hasDocsChanges = commitFiles.some(
      (fileName) => fileName.startsWith("docs/") || fileName === "mkdocs.yml",
    ),
    hasTestChanges = commitFiles.some(
      (fileName) => fileName.startsWith("tests/") || fileName === "pytest.ini",
    ),
    hasSourceChanges = commitFiles.some(
      (fileName) =>
        fileName.startsWith("src/") || fileName === "pyproject.toml",
    );

  if (hasDocsCommit & !hasDocsChanges) {
    fail("Commit with the 'docs' type should change documentation files");
    return;
  }

  if (hasTestCommit & !hasTestChanges) {
    fail("Commit with the 'test' type should change test files");
    return;
  }

  if (hasFixCommit & !hasSourceChanges) {
    fail("Commit with the 'fix' type should change source files");
    return;
  }

  if (hasFeatureCommit & !hasSourceChanges) {
    fail("Commit with the 'feat' type should change source files");
    return;
  }

  if (danger.github.pr.commits > 3) {
    fail("PR has too much commits");
    return;
  }

  if (commitTest.length !== commitTypes.size) {
    fail("PR can not contain commits with the same type");
    return;
  }

  const branchTest = danger.github.pr.head.ref.match(/^issue-(\d+)$/);

  if (!branchTest) {
    fail("Branch name should be 'issue-N' where N is the issue number");
    return;
  }

  const issueNumber = branchTest[1];

  if (danger.github.pr.body !== `Resolves #${issueNumber}`) {
    fail("PR should resolve related issue");
    return;
  }

  for (const commit of danger.git.commits) {
    if (!commit.message.split(/\r?\n/)[0].endsWith(` #${issueNumber}`)) {
      fail("The first line of each commit should ends with the issue number");
      return;
    }
  }

  const issueJSON = await danger.github.api.issues.get({
    owner: danger.github.thisPR.owner,
    repo: danger.github.thisPR.repo,
    issue_number: parseInt(issueNumber),
  });

  if (issueJSON.status !== 200) {
    fail(`Unable to check issue #${issueNumber}`);
    return;
  }

  if (issueJSON.data.closed_at) {
    fail("Closed issue can't be implemented");
    return;
  }

  if (issueJSON.data.milestone) {
    if (issueJSON.data.milestone.closed_at) {
      fail("Issues of closed milestone can't be implemented");
      return;
    }
  }

  if (issueJSON.data.assignee) {
    fail("Issue can't have an assignee");
    return;
  }

  const issueLabels = new Set(issueJSON.data.labels.map((label) => label.name)),
    hasIncompatibleLabel = issueLabels.has("backward incompatible"),
    hasFeatureLabel = issueLabels.has("feature"),
    hasBugLabel = issueLabels.has("bug"),
    hasDocumentationLabel = issueLabels.has("documentation"),
    hasQuestionLabel = issueLabels.has("question"),
    hasBlockedLabel = issueLabels.has("blocked");

  if (hasFeatureLabel & hasBugLabel) {
    fail("An issue can't be a bug and a feature simultaneously");
    return;
  }

  if (hasIncompatibleLabel ^ hasBreakingCommit) {
    fail(
      "Only issue marked as backward incompatible is allowed to have breaking changes",
    );
    return;
  }

  if (hasFeatureLabel ^ hasFeatureCommit) {
    fail("Only issue marked as feature is allowed to have feat commit");
    return;
  }

  if (hasBugLabel ^ hasFixCommit) {
    fail("Only issue marked as bug is allowed to have fix commit");
    return;
  }

  if (hasDocumentationLabel & !hasDocsCommit) {
    fail("Issue marked as documentation should have docs commit");
    return;
  }

  if (hasFeatureLabel & !hasDocsCommit) {
    fail("Issue marked as feature should have docs commit");
    return;
  }

  if (hasQuestionLabel & !hasDocsCommit) {
    fail("Issue marked as question should have docs commit");
    return;
  }

  if (hasBlockedLabel) {
    fail("Issues marked as blocked can not be implemented");
    return;
  }

  const issueText = issueJSON.data.body || "",
    issueLines = issueText.split(/\r?\n/).map((line) => line.trim());

  for (const line of issueLines) {
    if (line.match(/^[*+-] \[[xX]\] /)) {
      fail("Create a milestone instead of the issue with the task list");
      return;
    }
  }

  const labelsJSON = await danger.github.api.issues.listLabelsForRepo({
    owner: danger.github.thisPR.owner,
    repo: danger.github.thisPR.repo,
  });

  if (labelsJSON.status !== 200) {
    fail("Unable to check repository labels");
    return;
  }

  const allowedLabels = new Set([
    "backward incompatible",
    "blocked",
    "bug",
    "documentation",
    "feature",
    "question",
    "released",
  ]);

  for (const repoLabel of labelsJSON.data) {
    if (repoLabel.color !== "ededed") {
      fail(`The color of the ${repoLabel.name} should be 'ededed'`);
      return;
    } else if (repoLabel.description !== "") {
      fail(`The description of the ${repoLabel.name} should be empty`);
      return;
    } else if (!allowedLabels.has(repoLabel.name)) {
      fail(`Unknown label ${repoLabel.name}`);
      return;
    }
  }

  const milestonesJSON = await danger.github.api.issues.listMilestones({
    owner: danger.github.thisPR.owner,
    repo: danger.github.thisPR.repo,
  });

  if (milestonesJSON.status !== 200) {
    fail("Unable to check repository milestones");
    return;
  }

  for (const milestone of milestonesJSON.data) {
    if (milestone.description !== "") {
      fail(`The description of the ${milestone.title} should be empty`);
      return;
    } else if (milestone.due_on) {
      fail(`The due date of the ${milestone.title} should not be set`);
      return;
    }
  }
};