Enum Metric 

#[non_exhaustive]
pub enum Metric {
    Cognitive,
    Cyclomatic,
    Halstead,
    Loc,
    Nom,
    Tokens,
    Nargs,
    Nexits,
    Abc,
    Npm,
    Npa,
    Mi,
    Wmc,
}

One metric computed by the analysis walker.

Pass a slice of these to MetricsOptions::with_only to restrict computation to the listed metrics.

#[non_exhaustive] so future metrics can land additively. Use match against the existing variants and either a wildcard arm or the m if !MetricSet::all().contains(m) guard to stay forwards-compatible.

Ord follows declaration order, not the Display spelling. It exists so Metric can key a BTreeSet — notably the suppression scope (SuppressionScope::Some) — with a deterministic, stable iteration order across runs. Do not rely on the ordering being alphabetical; reorder the variants only with a deliberate review of every serialized BTreeSet<Metric> snapshot.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Cognitive

Cognitive complexity (crate::cognitive::Stats).

Cyclomatic

Cyclomatic complexity (crate::cyclomatic::Stats).

Halstead

Halstead (crate::halstead::Stats).

Loc

LoC family (crate::loc::Stats).

Nom

Number of methods (crate::nom::Stats).

Tokens

Token counts (crate::tokens::Stats).

Nargs

Number of arguments (crate::nargs::Stats).

Nexits

Exit-point count (crate::nexits::Stats).

Abc

ABC (crate::abc::Stats).

Npm

Number of public methods (crate::npm::Stats).

Npa

Number of public attributes (crate::npa::Stats).

Mi

Maintainability index (crate::mi::Stats). Derived metric: selecting only Mi via MetricsOptions::with_only also pulls in Metric::Loc, Metric::Cyclomatic, and Metric::Halstead.

Wmc

Weighted methods per class (crate::wmc::Stats). Derived metric: selecting Wmc also pulls in Metric::Cyclomatic and Metric::Nom.

Implementations

impl Metric

pub const NAMES: &'static [&'static str]

Canonical user-facing name for each metric — the single source of truth shared by the Python bindings’ bca.METRIC_NAMES constant, the unknown metric: <bad>; valid: … error message, and any downstream Rust consumer that parses user input into a MetricSet.

Each entry round-trips through Metric::from_str. Every metric uses one canonical spelling end-to-end: Metric::Nexits is "nexits" in Display, in this table, and as the JSON output key (the CodeMetrics::Serialize impl in src/spaces.rs).

Alphabetised. The drift between this table and the FromStr arms (or the Metric enum itself) is guarded by names_table_parses_to_every_variant and names_table_is_alphabetised in the test module below.

pub const fn dependencies(self) -> &'static [Metric]

Returns the slice of metrics this metric depends on.

Derived and averaged metrics consume the outputs of other metrics during the finalize step; selecting one without its dependencies would leave the dependency’s Stats at default (zero) values and silently corrupt the result. Callers typically reach this through MetricsOptions::with_only, which auto-resolves the closure transparently.

pub fn suppressible() -> impl Iterator<Item = Metric>

Every metric except Metric::Tokens, in declaration order.

tokens is the one metric with no configurable threshold, so it is the one metric that cannot be named in a suppression marker (bca: suppress(tokens) is rejected). This is the single source of truth for the suppressible vocabulary: the suppression parser’s “known metrics” hint and the threshold-name resolver both derive from it rather than hardcoding the list.

Trait Implementations

impl Clone for Metric

fn clone(&self) -> Metric

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Metric

impl Debug for Metric

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Metric

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Metric

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

Formats the value using the given formatter.

impl Eq for Metric

impl FromStr for Metric

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse a Metric from its fmt::Display spelling.

Strict lowercase: "Loc" is rejected. Every metric has exactly one accepted spelling, matching its Display form, NAMES entry, and JSON output key.

type Err = ParseMetricError

The associated error which can be returned from parsing.

impl Hash for Metric

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Metric

fn cmp(&self, other: &Metric) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Metric

fn eq(&self, other: &Metric) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Metric

fn partial_cmp(&self, other: &Metric) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Metric

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Metric