feluda 1.12.0

A CLI tool to check dependency licenses.
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
145
146
147
148
149
150
151
152
153
154
155
156
157

use std::sync::{Arc, Mutex};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::io::{self, Write};
use std::thread;
use std::time::Duration;
use colored::*;

/// TODO: Global progress tracker for coordinating multiple concurrent operations.
/// Will be used when implementing support for analyzing multiple root projects
/// simultaneously with per-project progress indicators.
#[allow(dead_code)]
pub struct ProgressTracker {
    #[allow(dead_code)]
    total: usize,
    completed: Arc<AtomicUsize>,
    #[allow(dead_code)]
    current_task: Arc<Mutex<String>>,
    running: Arc<Mutex<bool>>,
    handle: Arc<Mutex<Option<thread::JoinHandle<()>>>>,
}

impl ProgressTracker {
    /// TODO: Create a new progress tracker. Will be used when implementing
    /// multi-project analysis mode with detailed progress tracking per project.
    #[allow(dead_code)]
    pub fn new(total: usize) -> Self {
        Self {
            total,
            completed: Arc::new(AtomicUsize::new(0)),
            current_task: Arc::new(Mutex::new(String::new())),
            running: Arc::new(Mutex::new(false)),
            handle: Arc::new(Mutex::new(None)),
        }
    }

    /// TODO: Start the progress indicator thread. Will be used for displaying
    /// concurrent progress updates when analyzing multiple projects in parallel.
    #[allow(dead_code)]
    pub fn start(&self) {
        let total = self.total;

        *self.running.lock().unwrap() = true;

        let spinner_frames = vec!["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
        let completed_for_thread = Arc::clone(&self.completed);
        let current_task_for_thread = Arc::clone(&self.current_task);
        let running_for_thread = Arc::clone(&self.running);

        let handle = thread::spawn(move || {
            let mut frame_idx = 0;
            while *running_for_thread.lock().unwrap() {
                frame_idx = (frame_idx + 1) % spinner_frames.len();

                let completed_count = completed_for_thread.load(Ordering::Relaxed);
                let current = current_task_for_thread.lock().unwrap().clone();

                // Clear line and show progress
                print!("\x1B[2K\r");
                let spinner = spinner_frames[frame_idx].cyan();
                let progress_text = format!("[{}/{}]", completed_count, total);

                print!("{} {} ", spinner, "Analyzing projects".bright_white().bold());
                print!("{} ", progress_text.bright_cyan());

                if !current.is_empty() {
                    print!("({})", current.yellow());
                }

                io::stdout().flush().unwrap();
                thread::sleep(Duration::from_millis(80));
            }

            // Final message
            print!("\x1B[2K\r");
            println!(
                "{} {} {} {}",
                "✓".green().bold(),
                "Analyzed".bright_white().bold(),
                format!("{} projects", total).bright_cyan().bold(),
                "✅"
            );
            io::stdout().flush().unwrap();
        });

        if let Ok(mut h) = self.handle.lock() {
            *h = Some(handle);
        }
    }

    /// TODO: Update the current task being worked on. Will be used to display
    /// which specific project or analysis step is currently executing.
    #[allow(dead_code)]
    pub fn set_current_task(&self, task: impl Into<String>) {
        if let Ok(mut guard) = self.current_task.lock() {
            *guard = task.into();
        }
    }

    /// TODO: Mark a task as completed. Will be called to update progress counters
    /// as each project analysis completes in multi-project scenarios.
    #[allow(dead_code)]
    pub fn inc_completed(&self) {
        self.completed.fetch_add(1, Ordering::Relaxed);
    }

    /// Stop the progress indicator
    pub fn stop(&self) {
        if let Ok(mut guard) = self.running.lock() {
            *guard = false;
        }
        if let Ok(mut h) = self.handle.lock() {
            if let Some(handle) = h.take() {
                let _ = handle.join();
            }
        }
    }

    /// Get the current completion count
    #[allow(dead_code)]
    pub fn get_completed(&self) -> usize {
        self.completed.load(Ordering::Relaxed)
    }
}

impl Drop for ProgressTracker {
    fn drop(&mut self) {
        self.stop();
    }
}

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

    #[test]
    fn test_progress_tracker_creation() {
        let tracker = ProgressTracker::new(10);
        assert_eq!(tracker.total, 10);
        assert_eq!(tracker.completed.load(Ordering::Relaxed), 0);
    }

    #[test]
    fn test_progress_tracker_increment() {
        let tracker = ProgressTracker::new(5);
        tracker.inc_completed();
        tracker.inc_completed();
        assert_eq!(tracker.get_completed(), 2);
    }

    #[test]
    fn test_progress_tracker_set_task() {
        let tracker = ProgressTracker::new(1);
        tracker.set_current_task("test task");
        let task = tracker.current_task.lock().unwrap().clone();
        assert_eq!(task, "test task");
    }
}