iriq 0.35.0

IRI/URL extraction, normalization, and shape clustering.
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

use crate::classifier::{SegmentClassifier, SegmentType};
use crate::inflector::singularize;
use once_cell::sync::Lazy;
use std::collections::HashSet;

#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct SegmentHint {
    pub value: String,
    pub ty: SegmentType,
    pub variable: bool,
    pub hint: String,
}

static HINT_ELIGIBLE: Lazy<HashSet<SegmentType>> = Lazy::new(|| {
    [
        SegmentType::Integer,
        SegmentType::Uuid,
        SegmentType::Hash,
        SegmentType::OpaqueId,
        SegmentType::Slug,
    ]
    .into_iter()
    .collect()
});

pub fn derive_hints(segments: &[String], c: &SegmentClassifier) -> Vec<SegmentHint> {
    let mut out = Vec::with_capacity(segments.len());
    for (i, seg) in segments.iter().enumerate() {
        let t = c.classify(seg);
        let variable = c.variable(&t);
        let hint = hint_for(segments, i, &t, variable, c);
        out.push(SegmentHint {
            value: seg.clone(),
            ty: t,
            variable,
            hint,
        });
    }
    out
}

pub fn hint_for(
    segments: &[String],
    i: usize,
    t: &SegmentType,
    variable: bool,
    c: &SegmentClassifier,
) -> String {
    if !variable || i == 0 {
        return String::new();
    }
    if !HINT_ELIGIBLE.contains(t) {
        return String::new();
    }
    let prev = &segments[i - 1];
    if c.classify(prev) != SegmentType::Literal {
        return String::new();
    }
    let base = singularize(prev);
    let suffix = if *t == SegmentType::Uuid {
        "_uuid"
    } else {
        "_id"
    };
    format!("{}{}", base, suffix)
}

pub fn hint_eligible_types() -> &'static HashSet<SegmentType> {
    &HINT_ELIGIBLE
}