numbers-le 0.3.1

Extract every hardcoded number in a codebase, so a person can check them
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

pub(crate) mod corpus;
pub(crate) mod csv;
pub(crate) mod dotenv;
pub(crate) mod fallback;
pub(crate) mod format;
pub(crate) mod ini;
pub(crate) mod js;
pub(crate) mod json;
pub(crate) mod locate;
pub(crate) mod policy;
pub(crate) mod position;
pub(crate) mod render;
pub(crate) mod source;
pub(crate) mod toml;
pub(crate) mod yaml;

use serde::Serialize;

pub(crate) use format::{FALLBACK_FORMAT, SUPPORTED_FORMATS, resolve_format};
pub(crate) use policy::{Literal, Notation};
pub(crate) use position::Position;
pub(crate) use render::js_number;

/// What a caller can change about how a document is read.
///
/// Nothing yet. The extension's extractors take no options and inventing
/// some here would be this crate growing behaviour the extension then
/// has to be held to; the struct exists so adding one later is not a
/// signature change across every surface.
#[derive(Debug, Clone, Copy, Default)]
pub(crate) struct Options;

/// One extracted number, printed, and how the source wrote it.
///
/// `value` is text, not a JSON number. Re-encoding through a number
/// would hand the reader whatever their parser prints, which is the one
/// thing this crate exists to control.
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub(crate) struct Number {
    pub(crate) value: String,
    pub(crate) notation: Notation,
}

/// One extracted number, and where it was found.
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub(crate) struct Found {
    pub(crate) value: String,
    pub(crate) notation: Notation,
    #[serde(flatten)]
    pub(crate) position: Option<Position>,
}

/// Every number in a document, printed as JavaScript would print it, in
/// document order.
pub(crate) fn extract(text: &str, format: &str, _options: Options) -> Vec<Number> {
    raw(text, format)
        .into_iter()
        .map(|literal| Number {
            value: js_number(literal.value),
            notation: literal.notation,
        })
        .collect()
}

/// The literals themselves, before rendering.
pub(crate) fn raw(text: &str, format: &str) -> Vec<Literal> {
    let key = format::canonical(format);
    match key {
        "json" => json::extract(text, false),
        "jsonc" => json::extract(text, true),
        "yaml" => yaml::extract(text),
        "toml" => toml::extract(text),
        "ini" => ini::extract(text),
        "env" => dotenv::extract(text),
        "csv" => csv::extract(text, csv::COMMA),
        "tsv" => csv::extract(text, csv::TAB),
        _ if format::is_source(key) => source::extract(text, key),
        _ => fallback::extract(text),
    }
}

/// Every number, printed and placed.
pub(crate) fn extract_located(text: &str, format: &str, _options: Options) -> Vec<Found> {
    locate::locate(text, format, &raw(text, format))
}

/// Why a document yielded nothing, when the reason is a parse failure.
pub(crate) fn parse_error(text: &str, format: &str) -> Option<String> {
    match format::canonical(format) {
        "json" => json::parse_error(text, false),
        "jsonc" => json::parse_error(text, true),
        "yaml" => yaml::parse_error(text),
        "toml" => toml::parse_error(text),
        "ini" => ini::parse_error(text),
        "csv" => csv::parse_error(text, csv::COMMA),
        "tsv" => csv::parse_error(text, csv::TAB),
        // dotenv reads lines and the fallback scans runs; neither has a
        // shape it can reject.
        _ => None,
    }
}