whitaker-installer 0.2.3

Installer CLI for Whitaker Dylint lint libraries
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

# whitaker-installer

Installer CLI for [Whitaker](https://github.com/leynos/whitaker) Dylint lint
libraries.

Whitaker is a collection of opinionated Dylint lints for Rust. This installer
builds, links, and stages the lint libraries for local use, avoiding the need
to rebuild from source on each `cargo dylint` invocation. It also ensures the
pinned Rust toolchain and required components are installed via rustup.

## Installation

```bash
cargo install whitaker-installer
```

## Usage

### Install the default lint suite

```bash
whitaker-installer
```

This builds and stages the aggregated suite containing all standard lints.

### Install with experimental lints

```bash
whitaker-installer --experimental
```

At present, there are no experimental lints, so this flag is reserved for
future lint previews.

### Install specific lints

```bash
whitaker-installer -l module_max_lines -l no_expect_outside_tests
```

### Install all individual lint crates

```bash
whitaker-installer --individual-lints
```

### List installed lints

```bash
whitaker-installer list
```

Output as JSON for scripting:

```bash
whitaker-installer list --json
```

### Preview without building

```bash
whitaker-installer --dry-run
```

## Available Lints

Whitaker lints are divided into two categories:

- **Standard lints** are stable, well-tested, and included in the default suite.
  They are recommended for general use.
- **Experimental lints** are newer or more aggressive checks that may produce
  false positives or undergo breaking changes. They require the
  `--experimental` flag to install.

### Standard Lints

These lints are included when running `whitaker-installer` without flags:

| Lint                          | Description                                      |
| ----------------------------- | ------------------------------------------------ |
| `bumpy_road_function`         | Detect multiple complexity clusters in functions |
| `conditional_max_n_branches`  | Limit boolean branches in conditionals           |
| `function_attrs_follow_docs`  | Doc comments must precede other attributes       |
| `module_max_lines`            | Warn when modules exceed line threshold          |
| `module_must_have_inner_docs` | Require inner doc comments on modules            |
| `no_expect_outside_tests`     | Forbid `.expect()` outside test contexts         |
| `test_must_not_have_example`  | Forbid examples in test documentation            |
| `no_std_fs_operations`        | Enforce capability-based filesystem access       |
| `no_unwrap_or_else_panic`     | Deny panicking `unwrap_or_else` fallbacks        |

### Experimental Lints

There are currently no experimental lints. The `--experimental` flag remains
available for future releases that add preview lints.

## Using the Installed Lints

After installation, set `DYLINT_LIBRARY_PATH` to the staged directory and run
`cargo dylint`:

```bash
cargo dylint --all
```

The installer generates wrapper scripts and provides shell configuration
snippets to simplify this setup.

The wrappers are:

- `whitaker` — runs `cargo dylint` with the staged library path.
- `whitaker-ls` — lists installed Whitaker suite libraries for the staged
  path.

## Licence

ISC