Struct RuleSpec 

pub struct RuleSpec {
    pub id: String,
    pub kind: String,
    pub level: Level,
    pub paths: Option<PathsSpec>,
    pub message: Option<String>,
    pub policy_url: Option<String>,
    pub when: Option<String>,
    pub fix: Option<FixSpec>,
    pub git_tracked_only: bool,
    pub respect_gitignore: Option<bool>,
    pub scope_filter: Option<ScopeFilterSpec>,
    pub extra: Mapping,
}

YAML-level description of a rule before it is instantiated into a Box<dyn Rule> by a RuleBuilder.

Fields

id: String

kind: String

level: Level

paths: Option<PathsSpec>

message: Option<String>

policy_url: Option<String>

when: Option<String>

fix: Option<FixSpec>

Optional mechanical-fix strategy. Rules whose builders understand the chosen op attach a Fixer to the built rule; rules whose kind is incompatible with the op return a config error at build time.

git_tracked_only: bool

Restrict the rule to files / directories tracked in git’s index. When true, the rule’s paths-matched entries are intersected with the set of git-tracked files; entries that exist in the walked tree but aren’t in git ls-files output are skipped. Only meaningful for rule kinds that opt in (currently the existence family — file_exists, file_absent, dir_exists, dir_absent); rule kinds that don’t support it surface a clean config error when this is true so silent mis-configuration doesn’t slip through.

Default false. Has no effect outside a git repo.

respect_gitignore: Option<bool>

Per-rule override for the workspace-level respect_gitignore: setting. When Some(false), this rule treats .gitignore-listed files as if they were untracked-but-on-disk: the rule sees them. The canonical use case is the bazel-style “tracked AND gitignored” pattern (a file like .bazelversion ships a default upstream and contributors override it locally without committing the override) — the workspace walker honours the gitignore, so file_exists reports “no match” against a file that’s both on disk AND in git ls-files. This per-rule knob lets that single rule see the file without flipping the workspace-wide setting.

Currently honoured by file_exists for literal-path patterns (the common case the pitfall surfaced). Other rule kinds + glob patterns fall through to the workspace setting; future versions will broaden coverage.

Default None (inherit the workspace respect_gitignore). See docs/development/CONFIG-AUTHORING.md pitfall #18.

scope_filter: Option<ScopeFilterSpec>

Per-file ancestor-manifest gate. When set, the rule only fires on files that have at least one ancestor directory (including the file’s own directory) containing a file matching the configured has_ancestor name(s). Composes AND with paths: and git_tracked_only:.

Only meaningful for per-file rules; cross-file rule builders MUST reject this field at build time (see the design doc for the cross-file alternative via for_each_dir + when_iter:).

Default None (no scope filter; existing rules preserve their pre-v0.9.6 behaviour).

extra: Mapping

The entire YAML mapping, retained so each rule builder can deserialize its kind-specific fields without every option being represented here.

Implementations

impl RuleSpec

pub fn deserialize_options<T>(&self) -> Result<T>

where T: DeserializeOwned,

Deserialize the full spec (common + kind-specific fields) into a typed options struct. Common fields are reconstructed into the mapping so the target struct can #[derive(Deserialize)] against the whole shape when convenient.

pub fn parse_scope_filter(&self) -> Result<Option<ScopeFilter>>

Parse and validate this spec’s optional scope_filter: field into a built ScopeFilter. Returns Ok(None) when the spec has no scope_filter set (the common case).

Per-file rule builders typically don’t call this directly since v0.9.10 — they use Scope::from_spec instead, which bundles paths: + scope_filter: parsing into one call. The Scope owns the parsed filter and consults it inside Scope::matches, so the engine doesn’t need a separate per-rule accessor any more. Cross-file rules MUST NOT call this — they call reject_scope_filter_on_cross_file instead so a misconfigured scope_filter: on a cross- file rule surfaces as a clear build-time error rather than a silently-ignored field.

Trait Implementations

impl Clone for RuleSpec

fn clone(&self) -> RuleSpec

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RuleSpec

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RuleSpec

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.