Danger JS Documentation

To make your plugin discoverable and highlighted on the Danger website:

1. Update your package.json with your new version.
2. Include the tag "danger-plugin" in your package.json.
3. Import your module into your Dangerfile.

Once published, the Danger website will display your plugin's README.

The Danger JS DSL is fully typed via TypeScript. When you import danger in your Dangerfile, editors like Visual Studio Code provide inline documentation and auto-completion.

If your project uses Babel, your Dangerfile will use the same transpilation settings. If you use TypeScript + Jest, it works out of the box. For other setups, refer to the transpilation guide.

The danger local command allows you to run your Dangerfile rules locally using git hooks. This provides immediate feedback on your code before it is pushed to a remote repository.

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

Important Considerations:

• Platform Objects: In a local context, danger.github and danger.bitbucket will be falsy. If you share a Dangerfile between CI and local, ensure you check for the existence of these objects before accessing them.
• Branch Base: By default, it compares against master. If your reference branch is different, use the --base flag.

To move your Dangerfile rules into a reusable node module, use the generator-danger-plugin Yeoman generator. This creates a scaffolded project in either JavaScript or TypeScript.

1. Navigate to your project folder.
2. Install the Yeoman generator and the template globally: npm i -g yo generator-danger-plugin.
3. Run the generator: yo danger-plugin.

It is recommended to choose the TypeScript option for a better editor experience (e.g., in VS Code).

To force Danger to skip transpiling your Dangerfile (bypassing the automatic detection of Babel or TypeScript), set the following environment variable to "true":

DANGER_DISABLE_TRANSPILATION="true"

If you use a src folder for your source code and place a dangerfile.ts at the root, it may interfere with your project's compilation. To prevent this while still maintaining correct inline error reporting in your IDE, add dangerfile.ts to both the include and exclude sections of your tsconfig.json.

{
  "compilerOptions": {},
  "include": ["src/**/*.ts", "src/**/*.tsx", "dangerfile.ts"],
  "exclude": ["dangerfile.ts", "node_modules"]
}

The danger module is not a real module that can be imported in external environments; its exports are injected into the global environment during evaluation. If you attempt to import "danger" in code running outside of Danger, it will throw an exception. To test code that relies on danger, use a mocking system like Jest to fake the module and manipulate the global object (e.g., danger.github.pr).

jest.mock("danger", () => jest.fn())
import * as danger from "danger"
const dm = danger as any

// Example: Mocking the PR body to test logic
beforeEach(() => {
  dm.fail = jest.fn()
})

it("fails when there's no PR body", () => {
  dm.danger = { github: { pr: { body: "" } } }
  return rfc5().then(() => {
    expect(dm.fail).toHaveBeenCalledWith("Please add a description to your PR.")
  })
})