feat: init gritql python (#337)

crates/cli/src/commands/apply_pattern.rs

@@ -41,7 +41,7 @@ use marzano_messenger::{
     output_mode::OutputMode,
 };
 
-use crate::resolver::{get_grit_files_from_cwd, GritModuleResolver};
+use crate::resolver::{get_grit_files_from_flags_or_cwd, GritModuleResolver};
 use crate::utils::has_uncommitted_changes;
 
 use super::filters::SharedFilterArgs;
@@ -207,7 +207,7 @@ pub(crate) async fn run_apply_pattern(
     details: &mut ApplyDetails,
     pattern_libs: Option<BTreeMap<String, String>>,
     default_lang: Option<PatternLanguage>,
-    format: &GlobalFormatFlags,
+    format_flags: &GlobalFormatFlags,
     root_path: Option<PathBuf>,
 ) -> Result<()> {
     let mut context = Updater::from_current_bin()
@@ -217,7 +217,7 @@ pub(crate) async fn run_apply_pattern(
         .unwrap();
 
     let format = OutputFormat::from_flags(
-        format,
+        format_flags,
         if arg.stdin {
             OutputFormat::Transformed
         } else {
@@ -283,7 +283,7 @@ pub(crate) async fn run_apply_pattern(
     let module_resolution = span!(tracing::Level::INFO, "module_resolution",).entered();
 
     // Construct a resolver
-    let resolver = GritModuleResolver::new(cwd.to_str().unwrap());
+    let resolver = GritModuleResolver::new();
     let current_repo_root = marzano_gritmodule::fetcher::LocalRepo::from_dir(&cwd)
         .await
         .map(|repo| repo.root())
@@ -312,7 +312,14 @@ pub(crate) async fn run_apply_pattern(
         #[cfg(feature = "grit_tracing")]
         let stdlib_download_span = span!(tracing::Level::INFO, "stdlib_download",).entered();
 
-        let mod_dir = find_grit_modules_dir(cwd.clone()).await;
+        let target_grit_dir = format_flags
+            .grit_dir
+            .as_ref()
+            .and_then(|c| c.parent())
+            .unwrap_or_else(|| &cwd)
+            .to_path_buf();
+        let mod_dir = find_grit_modules_dir(target_grit_dir.clone()).await;
+
         if !env::var("GRIT_DOWNLOADS_DISABLED")
             .unwrap_or_else(|_| "false".to_owned())
             .parse::<bool>()
@@ -321,7 +328,7 @@ pub(crate) async fn run_apply_pattern(
         {
             flushable_unwrap!(
                 emitter,
-                init_config_from_cwd::<KeepFetcherKind>(cwd.clone(), false).await
+                init_config_from_cwd::<KeepFetcherKind>(target_grit_dir, false).await
             );
         }
 
@@ -349,7 +356,10 @@ pub(crate) async fn run_apply_pattern(
         #[cfg(feature = "grit_tracing")]
         let grit_file_discovery = span!(tracing::Level::INFO, "grit_file_discovery",).entered();
 
-        let pattern_libs = flushable_unwrap!(emitter, get_grit_files_from_cwd().await);
+        let pattern_libs = flushable_unwrap!(
+            emitter,
+            get_grit_files_from_flags_or_cwd(format_flags).await
+        );
 
         let (mut lang, pattern_body) = if pattern.ends_with(".grit") || pattern.ends_with(".md") {
             match fs::read_to_string(pattern.clone()).await {

crates/cli/src/commands/check.rs

@@ -36,7 +36,7 @@ use crate::{
     github::{log_check_annotations, write_check_summary},
     messenger_variant::create_emitter,
     resolver::{
-        get_grit_files_from, get_grit_files_from_cwd, resolve_from, resolve_from_cwd,
+        get_grit_files_from, get_grit_files_from_flags_or_cwd, resolve_from, resolve_from_cwd,
         GritModuleResolver, Source,
     },
     scan::log_check_json,
@@ -102,7 +102,10 @@ pub(crate) async fn run_check(
         grit_files.merge(global_files);
         (resolved, grit_files)
     } else {
-        try_join![resolve_from_cwd(&Source::All), get_grit_files_from_cwd()]?
+        try_join![
+            resolve_from_cwd(&Source::All),
+            get_grit_files_from_flags_or_cwd(format)
+        ]?
     };
 
     let enforced = resolved_patterns
@@ -122,7 +125,7 @@ pub(crate) async fn run_check(
     let filter_range = extract_filter_ranges(&arg.shared_filters, Some(&current_dir))?;
 
     // Construct a resolver
-    let resolver = GritModuleResolver::new(current_dir.to_str().unwrap());
+    let resolver = GritModuleResolver::new();
 
     let mut body_to_pattern: HashMap<String, &ResolvedGritDefinition> = HashMap::new();
     let compile_tasks: Result<HashMap<String, Problem>, _> = enforced

crates/cli/src/commands/parse.rs

@@ -1,8 +1,4 @@
-use crate::{
-    flags::GlobalFormatFlags,
-    jsonl::JSONLineMessenger,
-    resolver::{get_grit_files_from_cwd, GritModuleResolver},
-};
+use crate::{flags::GlobalFormatFlags, jsonl::JSONLineMessenger, resolver::GritModuleResolver};
 use anyhow::{bail, Result};
 use clap::Args;
 use grit_util::Position;
@@ -85,12 +81,12 @@ pub(crate) async fn run_parse(
     Ok(())
 }
 
+#[allow(deprecated)]
 async fn parse_one_pattern(body: String, path: Option<&PathBuf>) -> Result<MatchResult> {
-    let current_dir = std::env::current_dir()?;
-    let resolver = GritModuleResolver::new(current_dir.to_str().unwrap());
+    let resolver = GritModuleResolver::new();
     let lang = PatternLanguage::get_language(&body);
     let pattern = resolver.make_pattern(&body, None)?;
-    let pattern_libs = get_grit_files_from_cwd().await?;
+    let pattern_libs = crate::resolver::get_grit_files_from_cwd().await?;
     let pattern_libs = pattern_libs.get_language_directory_or_default(lang)?;
     let problem = match pattern.compile(&pattern_libs, None, None, None) {
         Ok(problem) => problem,

crates/cli/src/commands/patterns_list.rs

@@ -5,7 +5,7 @@ use marzano_gritmodule::config::{DefinitionSource, ResolvedGritDefinition};
 use crate::{
     flags::GlobalFormatFlags,
     lister::{list_applyables, Listable},
-    resolver::resolve_from_cwd,
+    resolver::{resolve_from_flags_or_cwd},
 };
 
 use super::list::ListArgs;
@@ -36,6 +36,6 @@ impl Listable for ResolvedGritDefinition {
 }
 
 pub(crate) async fn run_patterns_list(arg: ListArgs, parent: GlobalFormatFlags) -> Result<()> {
-    let (resolved, curr_repo) = resolve_from_cwd(&arg.source).await?;
+    let (resolved, curr_repo) = resolve_from_flags_or_cwd(&parent, &arg.source).await?;
     list_applyables(false, false, resolved, arg.level, &parent, curr_repo).await
 }

crates/cli/src/commands/patterns_test.rs

@@ -18,7 +18,9 @@ use rayon::iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIter
 use serde::Serialize;
 
 use crate::flags::{GlobalFormatFlags, OutputFormat};
-use crate::resolver::{get_grit_files_from_cwd, resolve_from_cwd, GritModuleResolver, Source};
+use crate::resolver::{
+    get_grit_files_from_flags_or_cwd, resolve_from_cwd, GritModuleResolver, Source,
+};
 use crate::result_formatting::FormattedResult;
 use crate::updater::Updater;
 use crate::ux::{indent, log_test_diff};
@@ -34,8 +36,7 @@ pub async fn get_marzano_pattern_test_results(
     args: PatternsTestArgs,
     output: OutputFormat,
 ) -> Result<()> {
-    let cwd = std::env::current_dir()?;
-    let resolver = GritModuleResolver::new(cwd.to_str().unwrap());
+    let resolver = GritModuleResolver::new();
 
     let final_results: DashMap<String, Vec<WrappedResult>> = DashMap::new();
     let unformatted_results: DashMap<PatternLanguage, Vec<WrappedResult>> = DashMap::new();
@@ -250,7 +251,7 @@ pub(crate) async fn run_patterns_test(
     flags: GlobalFormatFlags,
 ) -> Result<()> {
     let (mut patterns, _) = resolve_from_cwd(&Source::Local).await?;
-    let libs = get_grit_files_from_cwd().await?;
+    let libs = get_grit_files_from_flags_or_cwd(&flags).await?;
 
     if arg.filter.is_some() {
         let filter = arg.filter.as_ref().unwrap();

crates/cli/src/flags.rs

@@ -17,6 +17,9 @@ pub struct GlobalFormatFlags {
     /// Override the default log level (info)
     #[arg(long, global = true)]
     pub log_level: Option<log::LevelFilter>,
+    /// Override the default .grit directory location
+    #[arg(long, global = true)]
+    pub grit_dir: Option<std::path::PathBuf>,
 }
 
 #[derive(Debug, PartialEq, Clone)]

crates/cli/src/resolver.rs

@@ -3,7 +3,11 @@ use colored::Colorize;
 use core::fmt;
 use log::{info, warn};
 use serde::Serialize;
-use std::{collections::HashMap, path::PathBuf, str::FromStr};
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    str::FromStr,
+};
 
 use anyhow::{Context, Result};
 use marzano_gritmodule::{
@@ -14,7 +18,7 @@ use marzano_gritmodule::{
     searcher::find_grit_dir_from,
 };
 
-use crate::updater::Updater;
+use crate::{flags::GlobalFormatFlags, updater::Updater};
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum, Serialize, Debug)]
 #[serde(rename_all = "lowercase")]
@@ -28,8 +32,24 @@ pub enum Source {
 }
 
 // Equivalent to our PatternResolver in zesty, but more minimal
-pub struct GritModuleResolver<'a> {
-    _root_directory: &'a str,
+pub struct GritModuleResolver {}
+
+impl GritModuleResolver {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    pub fn make_pattern<'b>(
+        &self,
+        pattern_input: &'b str,
+        name: Option<String>,
+    ) -> Result<RichPattern<'b>> {
+        let pattern = RichPattern {
+            body: pattern_input,
+            name,
+        };
+        Ok(pattern)
+    }
 }
 
 #[derive(Debug)]
@@ -44,24 +64,16 @@ impl<'b> fmt::Display for RichPattern<'b> {
     }
 }
 
-impl<'a> GritModuleResolver<'a> {
-    pub fn new(root_directory: &'a str) -> Self {
-        Self {
-            _root_directory: root_directory,
-        }
-    }
+async fn from_known_grit_dir(config_path: &Path) -> Result<PatternsDirectory> {
+    let stdlib_modules = get_stdlib_modules();
 
-    pub fn make_pattern<'b>(
-        &self,
-        pattern_input: &'b str,
-        name: Option<String>,
-    ) -> Result<RichPattern<'b>> {
-        let pattern = RichPattern {
-            body: pattern_input,
-            name,
-        };
-        Ok(pattern)
-    }
+    let grit_parent = PathBuf::from(config_path.parent().context(format!(
+        "Unable to find parent of .grit directory at {}",
+        config_path.to_string_lossy()
+    ))?);
+    let parent_str = &grit_parent.to_string_lossy().to_string();
+    let repo = ModuleRepo::from_dir(config_path).await;
+    get_grit_files(&repo, parent_str, Some(stdlib_modules)).await
 }
 
 pub async fn get_grit_files_from(cwd: Option<PathBuf>) -> Result<PatternsDirectory> {
@@ -70,20 +82,12 @@ pub async fn get_grit_files_from(cwd: Option<PathBuf>) -> Result<PatternsDirecto
     } else {
         None
     };
-    let stdlib_modules = get_stdlib_modules();
 
     match existing_config {
-        Some(config) => {
-            let config_path = PathBuf::from_str(&config).unwrap();
-            let grit_parent = PathBuf::from(config_path.parent().context(format!(
-                "Unable to find parent of .grit directory at {}",
-                config
-            ))?);
-            let parent_str = &grit_parent.to_string_lossy().to_string();
-            let repo = ModuleRepo::from_dir(&config_path).await;
-            get_grit_files(&repo, parent_str, Some(stdlib_modules)).await
-        }
+        Some(config) => from_known_grit_dir(&PathBuf::from(config)).await,
         None => {
+            let stdlib_modules = get_stdlib_modules();
+
             let updater = Updater::from_current_bin().await?;
             let install_path = updater.install_path;
             let repo = ModuleRepo::from_dir(&install_path).await;
@@ -92,12 +96,36 @@ pub async fn get_grit_files_from(cwd: Option<PathBuf>) -> Result<PatternsDirecto
     }
 }
 
-#[tracing::instrument]
+/// Get the grit files from the current working directory
+#[deprecated = "Use get_grit_files_from_flags_or_cwd instead"]
 pub async fn get_grit_files_from_cwd() -> Result<PatternsDirectory> {
     let cwd = std::env::current_dir()?;
     get_grit_files_from(Some(cwd)).await
 }
 
+#[tracing::instrument]
+pub async fn get_grit_files_from_flags_or_cwd(
+    flags: &GlobalFormatFlags,
+) -> Result<PatternsDirectory> {
+    if let Some(grit_dir) = &flags.grit_dir {
+        from_known_grit_dir(grit_dir).await
+    } else {
+        let cwd = std::env::current_dir()?;
+        get_grit_files_from(Some(cwd)).await
+    }
+}
+
+pub async fn resolve_from_flags_or_cwd(
+    flags: &GlobalFormatFlags,
+    source: &Source,
+) -> Result<(Vec<ResolvedGritDefinition>, ModuleRepo)> {
+    if let Some(grit_dir) = &flags.grit_dir {
+        resolve_from(grit_dir.clone(), source).await
+    } else {
+        resolve_from_cwd(source).await
+    }
+}
+
 pub async fn resolve_from(
     cwd: PathBuf,
     source: &Source,

crates/cli_bin/fixtures/override_custom_grit_dir/.grit/patterns/mine.grit

@@ -0,0 +1,5 @@
+language python
+
+pattern special_pattern() {
+  `os.getenv` => `dotenv.mygoodness`
+}

crates/cli_bin/tests/apply.rs

@@ -2138,6 +2138,46 @@ fn ignores_file_in_grit_dir() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn override_grit_modules_at_apply() -> Result<()> {
+    // Grab the other grit directory
+    let (_temp_dir, other_dir) = get_fixture("override_custom_grit_dir", true)?;
+
+    // Keep _temp_dir around so that the tempdir is not deleted
+    let (_temp_dir, dir) = get_fixture("simple_python", false)?;
+    let origin_content = std::fs::read_to_string(dir.join("main.py"))?;
+
+    // from the tempdir as cwd, run marzano apply
+    let mut apply_cmd = get_test_cmd()?;
+    apply_cmd.current_dir(dir.as_path());
+    apply_cmd
+        .arg("apply")
+        .arg("--force")
+        .arg("special_pattern")
+        .arg("--grit-dir")
+        .arg(other_dir.join(".grit"));
+    let output = apply_cmd.output()?;
+
+    let stdout = String::from_utf8(output.stdout)?;
+    println!("stdout: {:?}", stdout);
+    let stderr = String::from_utf8(output.stderr)?;
+    println!("stderr: {:?}", stderr);
+
+    // Assert that the command failed
+    assert!(output.status.success(),);
+
+    // Read back the main.py file
+    let target_file = dir.join("main.py");
+    let content: String = std::fs::read_to_string(target_file)?;
+
+    assert_ne!(origin_content, content);
+
+    // Make sure it now has dotenv.mygoodness
+    assert!(content.contains("dotenv.mygoodness"));
+
+    Ok(())
+}
+
 #[test]
 fn language_option_file_pattern_apply() -> Result<()> {
     // Keep _temp_dir around so that the tempdir is not deleted