klepto 0.1.3

a general purpose extraction and data scraping utility
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
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use crate::model::*;
use crate::klepto::Klepto;
use blake3::Hasher;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FnFinger {
    pub fq_name: String,
    pub sig_hash: String,
    pub signature: String,
    pub location: FileLocation,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExportFinger {
    pub exported_as: String,
    pub source_path: String,
    pub location: FileLocation,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Snapshot {
    pub crate_name: String,
    pub no_std: bool,
    pub functions: Vec<FnFinger>,
    pub exports: Vec<ExportFinger>,
    pub imports: Vec<String>, // full paths
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SnapshotDiff {
    pub added_functions: Vec<FnFinger>,
    pub removed_functions: Vec<FnFinger>,
    pub changed_signatures: Vec<(FnFinger, FnFinger)>, // (old,new)

    pub added_exports: Vec<ExportFinger>,
    pub removed_exports: Vec<ExportFinger>,

    pub added_imports: Vec<String>,
    pub removed_imports: Vec<String>,
}

fn hash_sig(s: &str) -> String {
    let mut h = Hasher::new();
    h.update(s.as_bytes());
    h.finalize().to_hex().to_string()
}

impl Snapshot {
    pub fn from_klepto(k: &Klepto) -> Self {
        let functions = k.functions.iter().map(|f| FnFinger {
            fq_name: f.fq_name.clone(),
            sig_hash: hash_sig(&f.signature),
            signature: f.signature.clone(),
            location: f.location.clone(),
        }).collect();

        let exports = k.exports.iter().map(|e| ExportFinger {
            exported_as: e.exported_as.clone(),
            source_path: e.source_path.clone(),
            location: e.location.clone(),
        }).collect();

        let imports = {
            let mut v: Vec<String> = k.imports.iter().map(|i| i.full_path.clone()).collect();
            v.sort();
            v.dedup();
            v
        };

        Snapshot { crate_name: k.crate_name.clone(), no_std: k.no_std_detected, functions, exports, imports }
    }

    pub fn to_json_string(&self) -> String {
        serde_json::to_string_pretty(self).unwrap()
    }

    pub fn diff(&self, old: &Snapshot) -> SnapshotDiff {
        let mut old_map: BTreeMap<String, &FnFinger> = BTreeMap::new();
        for f in &old.functions { old_map.insert(f.fq_name.clone(), f); }

        let mut new_map: BTreeMap<String, &FnFinger> = BTreeMap::new();
        for f in &self.functions { new_map.insert(f.fq_name.clone(), f); }

        let mut added_functions = Vec::new();
        let mut removed_functions = Vec::new();
        let mut changed_signatures = Vec::new();

        for (k, nf) in &new_map {
            match old_map.get(k) {
                None => added_functions.push((*nf).clone()),
                Some(of) => {
                    if of.sig_hash != nf.sig_hash {
                        changed_signatures.push(((*of).clone(), (*nf).clone()));
                    }
                }
            }
        }
        for (k, of) in &old_map {
            if !new_map.contains_key(k) {
                removed_functions.push((*of).clone());
            }
        }

        let old_exports: BTreeSet<(String,String)> = old.exports.iter().map(|e| (e.exported_as.clone(), e.source_path.clone())).collect();
        let new_exports: BTreeSet<(String,String)> = self.exports.iter().map(|e| (e.exported_as.clone(), e.source_path.clone())).collect();

        let mut added_exports = Vec::new();
        let mut removed_exports = Vec::new();

        for e in &self.exports {
            if !old_exports.contains(&(e.exported_as.clone(), e.source_path.clone())) {
                added_exports.push(e.clone());
            }
        }
        for e in &old.exports {
            if !new_exports.contains(&(e.exported_as.clone(), e.source_path.clone())) {
                removed_exports.push(e.clone());
            }
        }

        let old_imports: BTreeSet<String> = old.imports.iter().cloned().collect();
        let new_imports: BTreeSet<String> = self.imports.iter().cloned().collect();

        let added_imports = new_imports.difference(&old_imports).cloned().collect();
        let removed_imports = old_imports.difference(&new_imports).cloned().collect();

        SnapshotDiff {
            added_functions,
            removed_functions,
            changed_signatures,
            added_exports,
            removed_exports,
            added_imports,
            removed_imports,
        }
    }
}