Danger Swift

When working with BitBucket Cloud pull requests in Danger Swift, the BitBucketCloud.PullRequest.Participant.Role enum is used to distinguish between different types of participants in a pull request. This enum conforms to Decodable and String.

There are two available roles:

• reviewer: Represents a user explicitly assigned as a reviewer.
• participant: Represents a user involved in the pull request who is not specifically a reviewer.

// The enum cases available for BitBucket Cloud pull request participants
public enum Role: String, Decodable {
    case reviewer
    case participant
}

Danger Swift includes specialized types for interacting with different VCS providers. Use these types to access metadata specific to your hosting service:

• GitHub: Access GitHub.PullRequest, GitHub.Repo, GitHub.User, and GitHub.Review.
• GitLab: Access GitLab.MergeRequest, GitLab.User, and GitLab.Metadata.
• BitBucket Cloud: Access BitBucketCloud.PullRequest, BitBucketCloud.Commit, and BitBucketCloud.Repo.
• BitBucket Server: Access BitBucketServer.PullRequest, BitBucketServer.Commit, and BitBucketServer.Project.
• Git: Generic access to Git.Commit and Git.Commit.Author.

These types allow you to write provider-agnostic logic or provider-specific logic when you need deep metadata (like labels, milestones, or specific reviewer states).

The GitHub struct provides access to metadata associated with your pull request on GitHub. It includes information about the issue, the pull request itself, commits, reviews, requested reviewers, and a direct interface to the Octokit API.

// Accessing the GitHub metadata object
let githubMetadata = context.github

To make testing easier, you can import Danger directly in your Package.swift.

Recommendation: If you define a dynamic library target (e.g., DangerDeps) for development purposes, use a tool like Rocket to comment it out before distribution. This prevents the DangerDeps library from being compiled and shipped to your users.

let package = Package(
    // ...
    products: [
        .library(name: "DangerPlugin", targets: ["DangerPlugin"]),
        .library(name: "DangerDeps", type: .dynamic, targets: ["DangerPlugin"]),
    ],
    dependencies: [
        .package(url: "https://github.com/danger/swift.git", from: "1.0.0"),
    ],
    targets: [
        .target(name: "DangerPlugin", dependencies: ["Danger"]),
    ]
)

The Git struct provides access to git-specific metadata associated with a pull request. You can use this to inspect changes made in the PR, such as which files were modified, created, or deleted, and to access information about the commits included in the PR.

// Accessing the git property on the danger object
let gitMetadata = danger.git

The FileDiff.Changes enum represents the type of change applied to a file in a pull request or commit. It conforms to Equatable and provides specific data depending on whether a file was created, deleted, modified, or renamed. You can use pattern matching to extract the specific lines or hunks associated with each change type.

// Example of pattern matching on FileDiff.Changes
switch change {
case .created(let addedLines):
    print("File created with lines: \(addedLines)")
case .deleted(let deletedLines):
    print("File deleted. Removed lines: \(deletedLines)")
case .modified(let hunks):
    print("File modified with \(hunks.count) hunks")
case .renamed(let oldPath, let hunks):
    print("File renamed from \(oldPath) with \(hunks.count) hunks")
}

The danger local command provides a way to run your Dangerfile using git-hooks, allowing you to get feedback on your rules while working locally before pushing to a Pull Request.

Unlike danger ci, which uses Pull Request metadata, danger local derives its environment from the local git differences between your current commit and the master branch.

Important for sharing Dangerfiles: When running locally, platform-specific objects like danger.github and danger.bitbucketServer will be nil. To share a single Dangerfile.swift between local and CI environments, you must verify that these objects exist before attempting to use them.

A recommended pattern is to create a separate, lightweight Dangerfile (e.g., Dangerfile.lite.swift) containing only rules that work with danger.git (such as CHANGELOG or README checks) and importing it into your main Dangerfile.

Depending on your hosting provider, Danger Swift provides specific metadata types to access PR details:

• GitHub: Access GitHub metadata, including GitHub.PullRequest, GitHub.User, GitHub.Repo, GitHub.Review, and GitHub.Issue.
• GitLab: Access GitLab metadata, including GitLab.MergeRequest, GitLab.User, and GitLab.Metadata.
• BitBucket Cloud: Access BitBucketCloud metadata, including BitBucketCloud.PullRequest, BitBucketCloud.Repo, and BitBucketCloud.User.
• BitBucket Server: Access BitBucketServer metadata, including BitBucketServer.PullRequest, BitBucketServer.Repo, and BitBucketServer.Project.

You can directly import a Swift PM package as a dependency in your Dangerfile.swift by suffixing the import with package: [url].

// Dangerfile.swift

import DangerPlugin // package: https://github.com/username/DangerPlugin.git

DangerPlugin.doYourThing()