workspacer 0.4.0

An asynchronous workspace management library for Rust projects, providing utilities for automation, analysis, and maintenance of multi-crate workspaces.
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
140
141
142
143
144

// ---------------- [ File: src/workspace_analysis.rs ]
crate::ix!();

#[async_trait]
impl<P,H:CrateHandleInterface<P>> Analyze for Workspace<P,H> 
where for<'async_trait> P: From<PathBuf> + AsRef<Path> + Send + Sync + 'async_trait
{

    type Analysis = WorkspaceSizeAnalysis;
    type Error    = WorkspaceError;

    async fn analyze(&self) -> Result<Self::Analysis, Self::Error> {

        let mut builder = WorkspaceSizeAnalysis::builder();

        for crate_handle in self {
            let crate_analysis = CrateAnalysis::new(crate_handle).await?;
            builder.add_crate_analysis(crate_analysis);
        }

        Ok(builder.build())
    }
}

#[derive(Debug,Clone)]
pub struct WorkspaceSizeAnalysis {
    crate_analyses: Vec<CrateAnalysis>, // Collection of crate analyses

    // Workspace-level metrics
    total_file_size:        u64,
    total_lines_of_code:    usize,
    total_source_files:     usize,
    total_test_files:       usize,
    largest_file_size:      u64,
    smallest_file_size:     u64,
    average_file_size:      f64,
    average_lines_per_file: f64,
}

impl WorkspaceSizeAnalysis {
    /// Starts the builder for `WorkspaceSizeAnalysis`
    pub fn builder() -> WorkspaceAnalysisBuilder {
        WorkspaceAnalysisBuilder::new()
    }

    // --- Accessors ---
    
    pub fn crate_analyses(&self) -> &Vec<CrateAnalysis> {
        &self.crate_analyses
    }

    pub fn total_file_size(&self) -> u64 {
        self.total_file_size
    }

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

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

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

    pub fn largest_file_size(&self) -> u64 {
        self.largest_file_size
    }

    pub fn smallest_file_size(&self) -> u64 {
        self.smallest_file_size
    }

    pub fn average_file_size(&self) -> f64 {
        self.average_file_size
    }

    pub fn average_lines_per_file(&self) -> f64 {
        self.average_lines_per_file
    }
}

pub struct WorkspaceAnalysisBuilder {
    crate_analyses: Vec<CrateAnalysis>, // Collection of crate analyses
}

impl WorkspaceAnalysisBuilder {
    pub fn new() -> Self {
        Self {
            crate_analyses: Vec::new(),
        }
    }

    /// Adds a crate analysis to the builder
    pub fn add_crate_analysis(&mut self, analysis: CrateAnalysis) -> &mut Self {
        self.crate_analyses.push(analysis);
        self
    }

    /// Builds and returns the `WorkspaceSizeAnalysis` by calculating workspace-level metrics
    pub fn build(&self) -> WorkspaceSizeAnalysis {
        let mut total_file_size     = 0;
        let mut total_lines_of_code = 0;
        let mut total_source_files  = 0;
        let mut total_test_files    = 0;
        let mut largest_file_size   = 0;
        let mut smallest_file_size  = u64::MAX;

        // Aggregate data from each crate analysis
        for crate_analysis in &self.crate_analyses {
            total_file_size     += crate_analysis.total_file_size();
            total_lines_of_code += crate_analysis.total_lines_of_code();
            total_source_files  += crate_analysis.total_source_files();
            total_test_files    += crate_analysis.total_test_files();
            largest_file_size   = largest_file_size.max(crate_analysis.largest_file_size());
            smallest_file_size  = smallest_file_size.min(crate_analysis.smallest_file_size());
        }

        let average_file_size = if total_source_files > 0 {
            total_file_size as f64 / total_source_files as f64
        } else {
            0.0
        };
        let average_lines_per_file = if total_source_files > 0 {
            total_lines_of_code as f64 / total_source_files as f64
        } else {
            0.0
        };

        WorkspaceSizeAnalysis {
            crate_analyses: self.crate_analyses.clone(),
            total_file_size,
            total_lines_of_code,
            total_source_files,
            total_test_files,
            largest_file_size,
            smallest_file_size,
            average_file_size,
            average_lines_per_file,
        }
    }
}