tree-sitter-stack-graphs 0.10.0

Create stack graphs using tree-sitter parsers
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

// -*- coding: utf-8 -*-
// ------------------------------------------------------------------------------------------------
// Copyright © 2023, stack-graphs authors.
// Licensed under either of Apache License, Version 2.0, or MIT license, at your option.
// Please see the LICENSE-APACHE or LICENSE-MIT files in this distribution for license details.
// ------------------------------------------------------------------------------------------------

use clap::ArgGroup;
use clap::Args;
use clap::ValueHint;
use stack_graphs::storage::FileEntry;
use stack_graphs::storage::FileStatus;
use stack_graphs::storage::SQLiteReader;
use std::path::Path;
use std::path::PathBuf;

use crate::cli::util::reporter::ConsoleReporter;
use crate::cli::util::reporter::Reporter;

#[derive(Args)]
#[clap(group(
    ArgGroup::new("paths")
        .required(true)
        .args(&["source_paths", "all"]),
))]
pub struct StatusArgs {
    /// Source file or directory paths.
    #[clap(
        value_name = "SOURCE_PATH",
        value_hint = ValueHint::AnyPath,
    )]
    pub source_paths: Vec<PathBuf>,

    /// Show status of all indexed source paths.
    #[clap(long, short = 'a')]
    pub all: bool,

    #[clap(long, short = 'v')]
    pub verbose: bool,
}

impl StatusArgs {
    pub fn run(self, db_path: &Path) -> anyhow::Result<()> {
        let reporter = self.get_reporter();
        let mut db = SQLiteReader::open(&db_path)?;
        if self.all {
            let mut files = db.list_all()?;
            let mut entries = files.try_iter()?;
            self.status(&mut entries, &reporter)?;
        } else {
            for source_path in &self.source_paths {
                let source_path = source_path.canonicalize()?;
                let mut files = db.list_file_or_directory(&source_path)?;
                let mut entries = files.try_iter()?;
                self.status(&mut entries, &reporter)?;
            }
        }
        Ok(())
    }

    fn get_reporter(&self) -> ConsoleReporter {
        if self.verbose {
            ConsoleReporter::details()
        } else {
            ConsoleReporter::summary()
        }
    }

    fn status(
        &self,
        entries: &mut impl Iterator<Item = stack_graphs::storage::Result<FileEntry>>,
        reporter: &dyn Reporter,
    ) -> anyhow::Result<()> {
        for entry in entries {
            let entry = entry?;
            reporter.started(&entry.path);
            match &entry.status {
                FileStatus::Missing => {
                    reporter.cancelled(&entry.path, "missing", None);
                }
                FileStatus::Indexed => {
                    reporter.succeeded(&entry.path, "indexed", None);
                }
                FileStatus::Error(error) => {
                    reporter.failed(&entry.path, "failed", Some(error));
                }
            }
        }
        Ok(())
    }
}