Add rudimentary analyze command

Author: Hendrik van Antwerpen

tree-sitter-stack-graphs/src/cli.rs

@@ -55,6 +55,7 @@
 
 pub(self) const MAX_PARSE_ERRORS: usize = 5;
 
+pub mod analyze;
 pub mod init;
 pub mod load;
 pub mod parse;
@@ -64,13 +65,15 @@ mod util;
 pub mod path_loading {
     use clap::Subcommand;
 
+    use crate::cli::analyze::AnalyzeArgs;
     use crate::cli::init::InitArgs;
     use crate::cli::load::PathLoaderArgs;
     use crate::cli::parse::ParseArgs;
     use crate::cli::test::TestArgs;
 
     #[derive(Subcommand)]
     pub enum Subcommands {
+        Analyze(Analyze),
         Init(Init),
         Parse(Parse),
         Test(Test),
@@ -79,13 +82,30 @@ pub mod path_loading {
     impl Subcommands {
         pub fn run(&self) -> anyhow::Result<()> {
             match self {
+                Self::Analyze(cmd) => cmd.run(),
                 Self::Init(cmd) => cmd.run(),
                 Self::Parse(cmd) => cmd.run(),
                 Self::Test(cmd) => cmd.run(),
             }
         }
     }
 
+    /// Analyze command
+    #[derive(clap::Parser)]
+    pub struct Analyze {
+        #[clap(flatten)]
+        load_args: PathLoaderArgs,
+        #[clap(flatten)]
+        analyze_args: AnalyzeArgs,
+    }
+
+    impl Analyze {
+        pub fn run(&self) -> anyhow::Result<()> {
+            let mut loader = self.load_args.get()?;
+            self.analyze_args.run(&mut loader)
+        }
+    }
+
     /// Init command
     #[derive(clap::Parser)]
     pub struct Init {
@@ -135,27 +155,45 @@ pub mod path_loading {
 pub mod provided_languages {
     use clap::Subcommand;
 
+    use crate::cli::analyze::AnalyzeArgs;
+    use crate::cli::load::LanguageConfigurationsLoaderArgs;
     use crate::cli::parse::ParseArgs;
     use crate::cli::test::TestArgs;
     use crate::loader::LanguageConfiguration;
 
-    use super::load::LanguageConfigurationsLoaderArgs;
-
     #[derive(Subcommand)]
     pub enum Subcommands {
+        Analyze(Analyze),
         Parse(Parse),
         Test(Test),
     }
 
     impl Subcommands {
         pub fn run(&self, configurations: Vec<LanguageConfiguration>) -> anyhow::Result<()> {
             match self {
+                Self::Analyze(cmd) => cmd.run(configurations),
                 Self::Parse(cmd) => cmd.run(configurations),
                 Self::Test(cmd) => cmd.run(configurations),
             }
         }
     }
 
+    /// Analyze command
+    #[derive(clap::Parser)]
+    pub struct Analyze {
+        #[clap(flatten)]
+        load_args: LanguageConfigurationsLoaderArgs,
+        #[clap(flatten)]
+        analyze_args: AnalyzeArgs,
+    }
+
+    impl Analyze {
+        pub fn run(&self, configurations: Vec<LanguageConfiguration>) -> anyhow::Result<()> {
+            let mut loader = self.load_args.get(configurations)?;
+            self.analyze_args.run(&mut loader)
+        }
+    }
+
     /// Parse command
     #[derive(clap::Parser)]
     pub struct Parse {

tree-sitter-stack-graphs/src/cli/analyze.rs

@@ -0,0 +1,163 @@
+// -*- coding: utf-8 -*-
+// ------------------------------------------------------------------------------------------------
+// Copyright © 2021, 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 anyhow::anyhow;
+use anyhow::Context as _;
+use clap::Args;
+use clap::ValueHint;
+use colored::Colorize as _;
+use stack_graphs::graph::StackGraph;
+use stack_graphs::partial::PartialPaths;
+use stack_graphs::stitching::Database;
+use std::collections::HashMap;
+use std::path::Path;
+use std::path::PathBuf;
+use tree_sitter_graph::Variables;
+use walkdir::WalkDir;
+
+use crate::cli::util::map_parse_errors;
+use crate::cli::util::path_exists;
+use crate::loader::Loader;
+use crate::LoadError;
+use crate::NoCancellation;
+
+/// Analyze sources
+#[derive(Args)]
+pub struct AnalyzeArgs {
+    /// Source file or directory paths.
+    #[clap(value_name = "SOURCE_PATH", required = true, value_hint = ValueHint::AnyPath, parse(from_os_str), validator_os = path_exists)]
+    pub source_paths: Vec<PathBuf>,
+
+    #[clap(short = 'v')]
+    pub verbose: bool,
+}
+
+impl AnalyzeArgs {
+    pub fn new(source_paths: Vec<PathBuf>) -> Self {
+        Self {
+            source_paths,
+            verbose: false,
+        }
+    }
+
+    pub fn run(&self, loader: &mut Loader) -> anyhow::Result<()> {
+        for source_path in &self.source_paths {
+            if source_path.is_dir() {
+                let source_root = source_path;
+                for source_entry in WalkDir::new(source_root)
+                    .follow_links(true)
+                    .into_iter()
+                    .filter_map(|e| e.ok())
+                    .filter(|e| e.file_type().is_file())
+                {
+                    let source_path = source_entry.path();
+                    self.run_with_context(source_root, source_path, loader)?;
+                }
+            } else {
+                let source_root = source_path.parent().unwrap();
+                self.run_with_context(source_root, source_path, loader)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Run test file and add error context to any failures that are returned.
+    fn run_with_context(
+        &self,
+        source_root: &Path,
+        source_path: &Path,
+        loader: &mut Loader,
+    ) -> anyhow::Result<()> {
+        self.analyze_file(source_root, source_path, loader)
+            .with_context(|| format!("Error analyzing file {}", source_path.display()))
+    }
+
+    /// Run test file.
+    fn analyze_file(
+        &self,
+        source_root: &Path,
+        source_path: &Path,
+        loader: &mut Loader,
+    ) -> anyhow::Result<()> {
+        if self.verbose {
+            eprint!("{} ", source_path.display());
+        }
+
+        let source = std::fs::read_to_string(source_path)?;
+        let lc = match loader.load_for_file(source_path, Some(&source), &NoCancellation)? {
+            Some(sgl) => sgl,
+            None => {
+                if self.verbose {
+                    eprintln!("{}", "⦵".dimmed());
+                }
+                return Ok(());
+            }
+        };
+
+        let mut graph = StackGraph::new();
+        let file = graph
+            .add_file(&source_path.to_string_lossy())
+            .map_err(|_| anyhow!("Duplicate file {}", source_path.display()))?;
+
+        if self.verbose {
+            eprint!("{} ", "🕸".yellow());
+        }
+        let relative_source_path = source_path.strip_prefix(source_root).unwrap();
+        let result = if let Some(fa) = source_path
+            .file_name()
+            .and_then(|f| lc.special_files.get(&f.to_string_lossy()))
+        {
+            fa.build_stack_graph_into(
+                &mut graph,
+                file,
+                &relative_source_path,
+                &source,
+                &mut std::iter::empty(),
+                &HashMap::new(),
+                &NoCancellation,
+            )
+        } else {
+            let globals = Variables::new();
+            lc.sgl
+                .build_stack_graph_into(&mut graph, file, &source, &globals, &NoCancellation)
+        };
+        match result {
+            Err(LoadError::ParseErrors(parse_errors)) => {
+                let parse_error = map_parse_errors(source_path, &parse_errors, &source);
+                if !self.verbose {
+                    eprint!("{}", source_path.display());
+                }
+                eprintln!("{}", "✗".red());
+                eprintln!("{}", parse_error);
+                return Ok(());
+            }
+            Err(e) => return Err(e.into()),
+            Ok(_) => {}
+        };
+
+        if self.verbose {
+            eprint!("{} ", "🦶".yellow());
+        }
+        let mut partials = PartialPaths::new();
+        let mut db = Database::new();
+        partials.find_all_partial_paths_in_file(
+            &graph,
+            file,
+            &stack_graphs::NoCancellation,
+            |g, ps, p| {
+                if p.is_complete_as_possible(g) {
+                    db.add_partial_path(g, ps, p);
+                }
+            },
+        )?;
+
+        if self.verbose {
+            eprintln!("{}", "✓".green());
+        }
+        Ok(())
+    }
+}