ast-grep-cli 0.25.2__tar.gz → 0.25.4__tar.gz

{ast_grep_cli-0.25.2 → ast_grep_cli-0.25.4}/Cargo.lock

@@ -113,7 +113,7 @@ dependencies = [
 
 [[package]]
 name = "ast-grep"
-version = "0.25.2"
+version = "0.25.4"
 dependencies = [
  "ansi_term",
  "anyhow",
@@ -145,7 +145,7 @@ dependencies = [
 
 [[package]]
 name = "ast-grep-config"
-version = "0.25.2"
+version = "0.25.4"
 dependencies = [
  "anyhow",
  "ast-grep-core",
@@ -161,7 +161,7 @@ dependencies = [
 
 [[package]]
 name = "ast-grep-core"
-version = "0.25.2"
+version = "0.25.4"
 dependencies = [
  "bit-set",
  "regex",
@@ -172,7 +172,7 @@ dependencies = [
 
 [[package]]
 name = "ast-grep-dynamic"
-version = "0.25.2"
+version = "0.25.4"
 dependencies = [
  "ast-grep-core",
  "ignore",
@@ -184,7 +184,7 @@ dependencies = [
 
 [[package]]
 name = "ast-grep-language"
-version = "0.25.2"
+version = "0.25.4"
 dependencies = [
  "ast-grep-core",
  "ignore",
@@ -209,13 +209,14 @@ dependencies = [
  "tree-sitter-ruby",
  "tree-sitter-rust",
  "tree-sitter-scala",
+ "tree-sitter-sql-bigquery",
  "tree-sitter-swift",
  "tree-sitter-typescript",
 ]
 
 [[package]]
 name = "ast-grep-lsp"
-version = "0.25.2"
+version = "0.25.4"
 dependencies = [
  "ast-grep-config",
  "ast-grep-core",
@@ -229,7 +230,7 @@ dependencies = [
 
 [[package]]
 name = "ast-grep-napi"
-version = "0.25.2"
+version = "0.25.4"
 dependencies = [
  "ast-grep-config",
  "ast-grep-core",
@@ -248,7 +249,7 @@ dependencies = [
 
 [[package]]
 name = "ast-grep-py"
-version = "0.25.2"
+version = "0.25.4"
 dependencies = [
  "anyhow",
  "ast-grep-config",
@@ -314,7 +315,7 @@ dependencies = [
 
 [[package]]
 name = "benches"
-version = "0.25.2"
+version = "0.25.4"
 dependencies = [
  "ast-grep-config",
  "ast-grep-core",
@@ -324,18 +325,18 @@ dependencies = [
 
 [[package]]
 name = "bit-set"
-version = "0.6.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0481a0e032742109b1133a095184ee93d88f3dc9e0d28a5d033dc77a073f44f"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
 dependencies = [
  "bit-vec",
 ]
 
 [[package]]
 name = "bit-vec"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2c54ff287cfc0a34f38a6b832ea1bd8e448a330b3e40a50859e6488bee07f22"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
 
 [[package]]
 name = "bitflags"
@@ -963,12 +964,12 @@ checksum = "ae743338b92ff9146ce83992f766a31066a91a8c84a45e0e9f21e7cf6de6d346"
 
 [[package]]
 name = "libloading"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e310b3a6b5907f99202fcdb4960ff45b93735d7c7d96b760fcff8db2dc0e103d"
+checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.5",
 ]
 
 [[package]]
@@ -1066,9 +1067,9 @@ checksum = "e1c0f5d67ee408a4685b61f5ab7e58605c8ae3f2b4189f0127d804ff13d5560a"
 
 [[package]]
 name = "napi-derive"
-version = "2.16.8"
+version = "2.16.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eafd2b920906ea5b1f5f1f9d1eff9cc74e4ff8124dca41b501c1413079589187"
+checksum = "87c3b5d4ab13e20a4bb9d3a1e2f3d4e77eee4a205d0f810abfd226b971dc6ce5"
 dependencies = [
  "cfg-if",
  "convert_case",
@@ -1080,9 +1081,9 @@ dependencies = [
 
 [[package]]
 name = "napi-derive-backend"
-version = "1.0.70"
+version = "1.0.71"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b370b784440c65eb9001d839012eb912ee43e3a2d0361e2c30c13052372c39fe"
+checksum = "96de436a6ab93265beef838f8333c8345438f059df6081fe0ad0b8648ee0c524"
 dependencies = [
  "convert_case",
  "once_cell",
@@ -1672,18 +1673,18 @@ checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
 
 [[package]]
 name = "thiserror"
-version = "1.0.62"
+version = "1.0.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2675633b1499176c2dff06b0856a27976a8f9d436737b4cf4f312d4d91d8bbb"
+checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.62"
+version = "1.0.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d20468752b09f49e909e55a5d338caa8bedf615594e9d80bc4c565d30faf798c"
+checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1727,9 +1728,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.38.0"
+version = "1.38.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a"
+checksum = "eb2caba9f80616f438e09748d5acda951967e1ea58508ef53d9c6402485a46df"
 dependencies = [
  "backtrace",
  "bytes",
@@ -1758,9 +1759,9 @@ checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
 
 [[package]]
 name = "toml_edit"
-version = "0.22.15"
+version = "0.22.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d59a3a72298453f564e2b111fa896f8d07fabb36f51f06d7e875fc5e0b5a3ef1"
+checksum = "278f3d518e152219c994ce877758516bca5e118eaed6996192a774fb9fbf0788"
 dependencies = [
  "indexmap",
  "toml_datetime",
@@ -1900,9 +1901,9 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-cpp"
-version = "0.22.2"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "537b7e0f0d8c89b8dd6f4d195814da94832f20720c09016c2a3ac3dc3c437993"
+checksum = "1d509a22a992790d38f2c291961ff8a1ff016c437c7ec6befc9220b8eec8918c"
 dependencies = [
  "cc",
  "tree-sitter",
@@ -2091,6 +2092,16 @@ dependencies = [
  "tree-sitter",
 ]
 
+[[package]]
+name = "tree-sitter-sql-bigquery"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03958a5b10ddcd25ed510cf95a9bbb36cad5837894f4b7743e6ce0e26875e463"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
 [[package]]
 name = "tree-sitter-swift"
 version = "0.4.2"

{ast_grep_cli-0.25.2 → ast_grep_cli-0.25.4}/Cargo.toml

@@ -7,7 +7,7 @@ resolver = "2"
 lto = true
 
 [workspace.package]
-version = "0.25.2"
+version = "0.25.4"
 authors = ["Herrington Darkholme <2883231+HerringtonDarkholme@users.noreply.github.com>"]
 edition = "2021"
 license = "MIT"
@@ -18,13 +18,13 @@ rust-version = "1.67"
 readme = "README.md"
 
 [workspace.dependencies]
-ast-grep-core = { path = "crates/core", version = "0.25.2" }
-ast-grep-config = { path = "crates/config", version = "0.25.2" }
-ast-grep-dynamic = { path = "crates/dynamic", version = "0.25.2" }
-ast-grep-language = { path = "crates/language", version = "0.25.2" }
-ast-grep-lsp = { path = "crates/lsp", version = "0.25.2" }
+ast-grep-core = { path = "crates/core", version = "0.25.4" }
+ast-grep-config = { path = "crates/config", version = "0.25.4" }
+ast-grep-dynamic = { path = "crates/dynamic", version = "0.25.4" }
+ast-grep-language = { path = "crates/language", version = "0.25.4" }
+ast-grep-lsp = { path = "crates/lsp", version = "0.25.4" }
 
-bit-set = { version = "0.6.0" }
+bit-set = { version = "0.8.0" }
 ignore = { version = "0.4.22" }
 regex = { version = "1.10.4" }
 serde = { version = "1.0.200", features = ["derive"] }

{ast_grep_cli-0.25.2 → ast_grep_cli-0.25.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ast-grep-cli
-Version: 0.25.2
+Version: 0.25.4
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{ast_grep_cli-0.25.2 → ast_grep_cli-0.25.4}/crates/cli/src/config.rs

@@ -1,5 +1,5 @@
 use crate::error::ErrorContext as EC;
-use crate::lang::{CustomLang, LanguageGlobs, SgLang};
+use crate::lang::{CustomLang, LanguageGlobs, SerializableInjection, SgLang};
 
 use anyhow::{Context, Result};
 use ast_grep_config::{
@@ -49,6 +49,9 @@ pub struct AstGrepConfig {
   /// additional file globs for languages
   #[serde(skip_serializing_if = "Option::is_none")]
   pub language_globs: Option<LanguageGlobs>,
+  /// injection config for embedded languages
+  #[serde(default, skip_serializing_if = "Vec::is_empty")]
+  pub language_injections: Vec<SerializableInjection>,
 }
 
 pub fn find_rules(
@@ -81,6 +84,7 @@ pub fn register_custom_language(config_path: Option<PathBuf>) -> Result<()> {
   if let Some(globs) = sg_config.language_globs {
     SgLang::register_globs(globs)?;
   }
+  SgLang::register_injections(sg_config.language_injections)?;
   Ok(())
 }
 

{ast_grep_cli-0.25.2 → ast_grep_cli-0.25.4}/crates/cli/src/error.rs

@@ -32,6 +32,7 @@ pub enum ErrorContext {
   InvalidGlobalUtils,
   GlobPattern,
   UnrecognizableLanguage(String),
+  LangInjection,
   // Run
   ParsePattern,
   LanguageNotSpecified,
@@ -71,7 +72,7 @@ impl ErrorContext {
       ReadConfiguration | ReadRule(_) | WalkRuleDir(_) | WriteFile(_) => 5,
       StdInIsNotInteractive => 6,
       ParseTest(_) | ParseRule(_) | ParseConfiguration | GlobPattern | ParsePattern
-      | InvalidGlobalUtils => 8,
+      | InvalidGlobalUtils | LangInjection => 8,
       CannotInferShell => 10,
       ProjectAlreadyExist | FileAlreadyExist(_) => 17,
       InsufficientCLIArgument(_) => 22,
@@ -147,6 +148,11 @@ impl ErrorMessage {
         "The pattern in files/ignore is not a valid glob. Please refer to doc and fix the error.",
         CONFIG_GUIDE,
       ),
+      LangInjection => Self::new(
+        "Cannot parse languageInjections in config",
+        "The rule in languageInjections is not valid. Please refer to doc and fix the error.",
+        CONFIG_GUIDE,
+      ),
       InvalidGlobalUtils => Self::new(
         "Error occurs when parsing global utility rules",
         "Please check the YAML rules inside the rule directory",

ast_grep_cli-0.25.4/crates/cli/src/lang/injection.rs

@@ -0,0 +1,244 @@
+use super::SgLang;
+use crate::error::ErrorContext as EC;
+use ast_grep_config::{DeserializeEnv, RuleCore, SerializableRuleCore};
+use ast_grep_core::{
+  language::{TSPoint, TSRange},
+  Doc, Language, Node, StrDoc,
+};
+
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+
+use std::collections::{HashMap, HashSet};
+use std::ptr::{addr_of, addr_of_mut};
+use std::str::FromStr;
+
+// NB, you should not use SgLang in the (de_serialize interface
+// since Injected is used before lang registration in sgconfig.yml
+#[derive(Serialize, Deserialize, Clone)]
+#[serde(untagged)]
+pub enum Injected {
+  Static(String),
+  Dynamic(Vec<String>),
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SerializableInjection {
+  #[serde(flatten)]
+  core: SerializableRuleCore,
+  /// The host language, e.g. html, contains other languages
+  host_language: String,
+  /// Injected language according to the rule
+  /// It accepts either a string like js for single static language.
+  /// or an array of string like [js, ts] for dynamic language detection.
+  injected: Injected,
+}
+
+struct Injection {
+  host: SgLang,
+  rules: Vec<(RuleCore<SgLang>, Option<String>)>,
+  injectable: HashSet<String>,
+}
+
+impl Injection {
+  fn new(lang: SgLang) -> Self {
+    Self {
+      host: lang,
+      rules: vec![],
+      injectable: Default::default(),
+    }
+  }
+}
+
+pub unsafe fn register_injetables(injections: Vec<SerializableInjection>) -> Result<()> {
+  let mut injectable = HashMap::new();
+  for injection in injections {
+    register_injetable(injection, &mut injectable)?;
+  }
+  merge_default_injecatable(&mut injectable);
+  *addr_of_mut!(LANG_INJECTIONS) = injectable.into_values().collect();
+  let injects = unsafe { &*addr_of!(LANG_INJECTIONS) as &'static Vec<Injection> };
+  *addr_of_mut!(INJECTABLE_LANGS) = injects
+    .iter()
+    .map(|inj| {
+      (
+        inj.host,
+        inj.injectable.iter().map(|s| s.as_str()).collect(),
+      )
+    })
+    .collect();
+  Ok(())
+}
+
+fn merge_default_injecatable(ret: &mut HashMap<SgLang, Injection>) {
+  for (lang, injection) in ret {
+    let langs = match lang {
+      SgLang::Builtin(b) => b.injectable_languages(),
+      SgLang::Custom(c) => c.injectable_languages(),
+    };
+    let Some(langs) = langs else {
+      continue;
+    };
+    injection
+      .injectable
+      .extend(langs.iter().map(|s| s.to_string()));
+  }
+}
+
+fn register_injetable(
+  injection: SerializableInjection,
+  injectable: &mut HashMap<SgLang, Injection>,
+) -> Result<()> {
+  let lang = SgLang::from_str(&injection.host_language)?;
+  let env = DeserializeEnv::new(lang);
+  let rule = injection.core.get_matcher(env).context(EC::LangInjection)?;
+  let default_lang = match &injection.injected {
+    Injected::Static(s) => Some(s.clone()),
+    Injected::Dynamic(_) => None,
+  };
+  let entry = injectable
+    .entry(lang)
+    .or_insert_with(|| Injection::new(lang));
+  match injection.injected {
+    Injected::Static(s) => {
+      entry.injectable.insert(s);
+    }
+    Injected::Dynamic(v) => entry.injectable.extend(v),
+  }
+  entry.rules.push((rule, default_lang));
+  Ok(())
+}
+
+static mut LANG_INJECTIONS: Vec<Injection> = vec![];
+static mut INJECTABLE_LANGS: Vec<(SgLang, Vec<&'static str>)> = vec![];
+
+pub fn injectable_languages(lang: SgLang) -> Option<&'static [&'static str]> {
+  // NB: custom injection and builtin injections are resolved in INJECTABLE_LANGS
+  let injections =
+    unsafe { &*addr_of!(INJECTABLE_LANGS) as &'static Vec<(SgLang, Vec<&'static str>)> };
+  let Some(injection) = injections.iter().find(|i| i.0 == lang) else {
+    return match lang {
+      SgLang::Builtin(b) => b.injectable_languages(),
+      SgLang::Custom(c) => c.injectable_languages(),
+    };
+  };
+  Some(&injection.1)
+}
+
+pub fn extract_injections<D: Doc>(root: Node<D>) -> HashMap<String, Vec<TSRange>> {
+  // NB Only works in the CLI crate because we only has Node<SgLang>
+  let root: Node<StrDoc<SgLang>> = unsafe { std::mem::transmute(root) };
+  let mut ret = match root.lang() {
+    SgLang::Custom(c) => c.extract_injections(root.clone()),
+    SgLang::Builtin(b) => b.extract_injections(root.clone()),
+  };
+  let injections = unsafe { &*addr_of!(LANG_INJECTIONS) };
+  extract_custom_inject(injections, root, &mut ret);
+  ret
+}
+
+fn extract_custom_inject(
+  injections: &[Injection],
+  root: Node<StrDoc<SgLang>>,
+  ret: &mut HashMap<String, Vec<TSRange>>,
+) {
+  let Some(rules) = injections.iter().find(|n| n.host == *root.lang()) else {
+    return;
+  };
+  for (rule, default_lang) in &rules.rules {
+    for m in root.find_all(rule) {
+      let env = m.get_env();
+      let Some(region) = env.get_match("CONTENT") else {
+        continue;
+      };
+      let Some(lang) = env
+        .get_match("LANG")
+        .map(|n| n.text().to_string())
+        .or_else(|| default_lang.clone())
+      else {
+        continue;
+      };
+      let range = node_to_range(region);
+      ret.entry(lang).or_default().push(range);
+    }
+  }
+}
+
+fn node_to_range<D: Doc>(node: &Node<D>) -> TSRange {
+  let r = node.range();
+  let start = node.start_pos();
+  let sp = TSPoint::new(start.0 as u32, start.1 as u32);
+  let end = node.end_pos();
+  let ep = TSPoint::new(end.0 as u32, end.1 as u32);
+  TSRange::new(r.start as u32, r.end as u32, &sp, &ep)
+}
+
+#[cfg(test)]
+mod test {
+  use super::*;
+  use ast_grep_config::from_str;
+  use ast_grep_language::SupportLang;
+  const DYNAMIC: &str = "
+hostLanguage: js
+rule:
+  pattern: styled.$LANG`$CONTENT`
+injected: [css]";
+  const STATIC: &str = "
+hostLanguage: js
+rule:
+  pattern: styled`$CONTENT`
+injected: css";
+  #[test]
+  fn test_deserialize() {
+    let inj: SerializableInjection = from_str(STATIC).expect("should ok");
+    assert!(matches!(inj.injected, Injected::Static(_)));
+    let inj: SerializableInjection = from_str(DYNAMIC).expect("should ok");
+    assert!(matches!(inj.injected, Injected::Dynamic(_)));
+  }
+
+  const BAD: &str = "
+hostLanguage: HTML
+rule:
+  kind: not_exist
+injected: [js, ts, tsx]";
+
+  #[test]
+  fn test_bad_inject() {
+    let mut map = HashMap::new();
+    let inj: SerializableInjection = from_str(BAD).expect("should ok");
+    let ret = register_injetable(inj, &mut map);
+    assert!(ret.is_err());
+    let ec = ret.unwrap_err().downcast::<EC>().expect("should ok");
+    assert!(matches!(ec, EC::LangInjection));
+  }
+
+  #[test]
+  fn test_good_injection() {
+    let mut map = HashMap::new();
+    let inj: SerializableInjection = from_str(STATIC).expect("should ok");
+    let ret = register_injetable(inj, &mut map);
+    assert!(ret.is_ok());
+    let inj: SerializableInjection = from_str(DYNAMIC).expect("should ok");
+    let ret = register_injetable(inj, &mut map);
+    assert!(ret.is_ok());
+    assert_eq!(map.len(), 1);
+    let injections: Vec<_> = map.into_values().collect();
+    let mut ret = HashMap::new();
+    let sg =
+      SgLang::from(SupportLang::JavaScript).ast_grep("const a = styled`.btn { margin: 0; }`");
+    let root = sg.root();
+    extract_custom_inject(&injections, root, &mut ret);
+    assert_eq!(ret.len(), 1);
+    assert_eq!(ret["css"].len(), 1);
+    assert!(!ret.contains_key("js"));
+    ret.clear();
+    let sg =
+      SgLang::from(SupportLang::JavaScript).ast_grep("const a = styled.css`.btn { margin: 0; }`");
+    let root = sg.root();
+    extract_custom_inject(&injections, root, &mut ret);
+    assert_eq!(ret.len(), 1);
+    assert_eq!(ret["css"].len(), 1);
+    assert!(!ret.contains_key("js"));
+  }
+}

{ast_grep_cli-0.25.2 → ast_grep_cli-0.25.4}/crates/cli/src/lang.rs

@@ -1,4 +1,5 @@
 mod custom_lang;
+mod injection;
 mod lang_globs;
 
 use anyhow::Result;
@@ -18,9 +19,10 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 
 pub use custom_lang::CustomLang;
+pub use injection::SerializableInjection;
 pub use lang_globs::LanguageGlobs;
 
-#[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 #[serde(untagged)]
 pub enum SgLang {
   // inlined support lang expando char
@@ -51,6 +53,10 @@ impl SgLang {
     Ok(())
   }
 
+  pub fn register_injections(injections: Vec<SerializableInjection>) -> Result<()> {
+    unsafe { injection::register_injetables(injections) }
+  }
+
   pub fn all_langs() -> Vec<Self> {
     let builtin = SupportLang::all_langs().iter().copied().map(Self::Builtin);
     let customs = DynamicLang::all_langs().into_iter().map(Self::Custom);
@@ -180,17 +186,11 @@ impl Language for SgLang {
   }
 
   fn injectable_languages(&self) -> Option<&'static [&'static str]> {
-    match self {
-      Builtin(b) => b.injectable_languages(),
-      Custom(c) => c.injectable_languages(),
-    }
+    injection::injectable_languages(*self)
   }
 
   fn extract_injections<D: Doc>(&self, root: Node<D>) -> HashMap<String, Vec<TSRange>> {
-    match self {
-      Builtin(b) => b.extract_injections(root),
-      Custom(c) => c.extract_injections(root),
-    }
+    injection::extract_injections(root)
   }
 }
 

{ast_grep_cli-0.25.2 → ast_grep_cli-0.25.4}/crates/cli/src/new.rs

@@ -212,8 +212,9 @@ fn create_new_project(arg: NewArg) -> Result<()> {
     rule_dirs: vec![rule_dirs],
     test_configs: test_dirs.map(|t| vec![t]),
     util_dirs: utils.map(|u| vec![u]),
-    custom_languages: None, // advanced feature, skip now
-    language_globs: None,   // advanced feature, skip now
+    custom_languages: None,      // advanced feature, skip now
+    language_globs: None,        // advanced feature, skip now
+    language_injections: vec![], // advanced feature
   };
   let config_path = arg.base_dir.join("sgconfig.yml");
   let f = File::create(config_path)?;

{ast_grep_cli-0.25.2 → ast_grep_cli-0.25.4}/crates/cli/src/utils.rs

@@ -159,7 +159,15 @@ fn filter_result(result: Result<DirEntry, ignore::Error>) -> Option<PathBuf> {
       return None;
     }
   };
-  entry.file_type()?.is_file().then(|| entry.into_path())
+  if !entry.file_type()?.is_file() {
+    return None;
+  }
+  let path = entry.into_path();
+  // TODO: is it correct here? see https://github.com/ast-grep/ast-grep/issues/1343
+  match path.strip_prefix("./") {
+    Ok(p) => Some(p.to_path_buf()),
+    Err(_) => Some(path),
+  }
 }
 
 fn run_worker<W: PathWorker + ?Sized + 'static>(worker: Arc<W>) -> Result<()> {