scraps 3.5.0

Scraps is a portable CLI knowledge hub for managing interconnected Markdown documentation with Wiki-link notation.
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

use crate::error::ScrapsResult;
use crate::usecase::scrap::scrap_ref::{ScrapRef, find_scrap};
use scraps_libs::model::key::ScrapKey;
use scraps_libs::model::scrap::Scrap;
use scraps_libs::model::source::Source;
use scraps_libs::model::verification::{TrustTier, Verification};
use serde_json::Value;

/// Result for get scrap operation
#[derive(Debug, Clone, PartialEq)]
pub struct GetScrapResult {
    pub scrap: ScrapRef,
    pub md_text: String,
    pub scrap_type: Option<String>,
    pub description: Option<String>,
    pub frontmatter: Option<Value>,
    pub verifications: Vec<Verification>,
    pub trust_tier: TrustTier,
    pub sources: Vec<Source>,
}

pub struct GetScrapUsecase;

impl GetScrapUsecase {
    pub fn new() -> GetScrapUsecase {
        GetScrapUsecase
    }

    pub fn execute(&self, scraps: &[Scrap], key: &ScrapKey) -> ScrapsResult<GetScrapResult> {
        let target_scrap = find_scrap(scraps, key)?;

        Ok(GetScrapResult {
            scrap: target_scrap.into(),
            md_text: target_scrap.md_text().to_string(),
            scrap_type: target_scrap.scrap_type().map(str::to_string),
            description: target_scrap.description().map(str::to_string),
            frontmatter: target_scrap.frontmatter().cloned(),
            verifications: target_scrap.verifications(),
            trust_tier: target_scrap.trust_tier(),
            sources: target_scrap.sources(),
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_get_scrap_success() {
        let scraps = vec![Scrap::new(
            "scrap1",
            &None,
            "# Scrap 1\n\nContent of scrap 1.",
        )];

        let usecase = GetScrapUsecase::new();

        let result = usecase
            .execute(&scraps, &ScrapKey::from_path_str("scrap1"))
            .expect("Should succeed");

        assert_eq!(result.scrap.title, "scrap1");
        assert!(result.scrap.ctx().is_none());
        assert!(result.md_text.contains("Content of scrap 1"));
    }

    #[test]
    fn test_get_scrap_with_context() {
        let scraps = vec![Scrap::new(
            "scrap1",
            &Some("Context".into()),
            "# Scrap 1\n\nContent of scrap 1.",
        )];

        let usecase = GetScrapUsecase::new();

        let result = usecase
            .execute(&scraps, &ScrapKey::from_path_str("Context/scrap1"))
            .expect("Should succeed");

        assert_eq!(result.scrap.title, "scrap1");
        assert_eq!(result.scrap.key.to_string(), "Context/scrap1");
        assert!(result.md_text.contains("Content of scrap 1"));
    }

    #[test]
    fn test_get_scrap_carries_the_frontmatter_block() {
        let scraps = vec![
            Scrap::new("typed", &None, "---\ntype: Blog\n---\n\n# Typed\n"),
            Scrap::new("plain", &None, "# Plain\n"),
        ];

        let usecase = GetScrapUsecase::new();

        let typed = usecase.execute(&scraps, &ScrapKey::from_path_str("typed"));
        assert_eq!(
            typed.unwrap().frontmatter,
            Some(serde_json::json!({"type": "Blog"}))
        );

        let plain = usecase.execute(&scraps, &ScrapKey::from_path_str("plain"));
        assert_eq!(plain.unwrap().frontmatter, None);
    }

    #[test]
    fn test_get_scrap_not_found() {
        let scraps = vec![Scrap::new("scrap1", &None, "# Scrap 1\n\nContent.")];

        let usecase = GetScrapUsecase::new();

        let result = usecase.execute(&scraps, &ScrapKey::from_path_str("nonexistent"));

        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("Scrap not found"));
    }
}