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

use std::collections::HashMap;

/// Insertion-ordered string → string map. Mirrors Ruby Hash ordering for
/// query parameters and other fields where users see the declared order.
///
/// Values are `Option<String>` because Ruby distinguishes a valueless param
/// ("?flag" → nil) from an empty one ("?flag=" → ""). Downstream consumers
/// treat both as "" (Ruby calls `.to_s`); only the raw parse dump surfaces
/// the difference — use `iter_raw` there.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct OrderedMap {
    keys: Vec<String>,
    values: HashMap<String, Option<String>>,
}

impl OrderedMap {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn len(&self) -> usize {
        self.keys.len()
    }

    pub fn is_empty(&self) -> bool {
        self.keys.is_empty()
    }

    pub fn set(&mut self, k: impl Into<String>, v: Option<String>) {
        let key = k.into();
        if !self.values.contains_key(&key) {
            self.keys.push(key.clone());
        }
        self.values.insert(key, v);
    }

    pub fn get(&self, k: &str) -> Option<&str> {
        self.values.get(k).and_then(|v| v.as_deref())
    }

    pub fn keys(&self) -> Vec<String> {
        self.keys.clone()
    }

    /// Values with nil collapsed to "" — Ruby's `.to_s` view.
    pub fn iter(&self) -> impl Iterator<Item = (&str, &str)> {
        self.iter_raw().map(|(k, v)| (k, v.unwrap_or("")))
    }

    /// Values as parsed: None for "?flag", Some("") for "?flag=".
    pub fn iter_raw(&self) -> impl Iterator<Item = (&str, Option<&str>)> {
        self.keys
            .iter()
            .map(move |k| (k.as_str(), self.values.get(k).and_then(|v| v.as_deref())))
    }
}