feat: implementing jinja templater

.github/workflows/pr.yaml

@@ -83,14 +83,19 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - id: setup-python
+        uses: actions/setup-python@v5
+      - name: Install dependencies
+        run: make python_install
+      - name: Add site-packages to PYTHONPATH
+        run: echo "PYTHONPATH=$(python -c 'import site; print(site.getsitepackages()[0])'):\$PYTHONPATH" >> $GITHUB_ENV
+      - name: Run tests in cli
+        run: cargo test --manifest-path ./crates/cli/Cargo.toml
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
       - uses: taiki-e/install-action@nextest
       - name: Run all tests apart from cli
         run: cargo test --all --all-features --exclude sqruff
-      - name: Run tests in cli
-        run: cargo test --manifest-path ./crates/cli/Cargo.toml
       - name: Check for diffs
         run: git diff --quiet || exit 1
   benchmark:

crates/cli/Cargo.toml

@@ -58,7 +58,7 @@ name = "ui_json"
 harness = false
 
 [features]
-python = ["sqruff-lib/python"]
+python = ["sqruff-lib/python", "pyo3"]
 codegen-docs = ["clap-markdown", "minijinja", "serde", "python"]
 
 [dependencies]
@@ -69,6 +69,7 @@ strum_macros.workspace = true
 clap = { version = "4", features = ["derive"] }
 console = "0.15.8"
 ignore = "0.4.23"
+pyo3 = { version = "0.23.3", features = ["auto-initialize"], optional = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 mimalloc = "0.1"

crates/cli/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["maturin>=1.0"] 
+requires = ["maturin>=1.8"]
 build-backend = "maturin" 
 
 [project]

crates/cli/src/commands.rs

@@ -22,12 +22,17 @@ pub(crate) struct Cli {
 
 #[derive(Debug, Subcommand)]
 pub(crate) enum Commands {
-    #[command(name = "lint", about = "lint files")]
+    #[command(name = "lint", about = "Lint files")]
     Lint(LintArgs),
-    #[command(name = "fix", about = "fix files")]
+    #[command(name = "fix", about = "Fix files")]
     Fix(FixArgs),
     #[command(name = "lsp", about = "Run an LSP server")]
     Lsp,
+    #[command(
+        name = "info",
+        about = "Print information about sqruff and the current environment"
+    )]
+    Info,
 }
 
 #[derive(Debug, Parser)]

crates/cli/src/commands_info.rs

@@ -0,0 +1,60 @@
+pub(crate) fn info() {
+    // Print information about the current environment
+    println!("Rust Version: {}", env!("CARGO_PKG_VERSION"));
+
+    // Print information about python
+    #[cfg(feature = "python")]
+    {
+        use pyo3::prelude::*;
+        use pyo3::types::{PyList, PyMapping, PyString};
+
+        // Acquire the Global Interpreter Lock (GIL) and open a Python context
+        Python::with_gil(|py| {
+            // Import the sys module
+            let sys = py.import("sys").unwrap();
+
+            // Get some attributes from sys
+            let version = sys.getattr("version").unwrap();
+            let version = version.downcast().unwrap();
+            let executable = sys.getattr("executable").unwrap();
+            let executable = executable.downcast().unwrap();
+            let prefix = sys.getattr("prefix").unwrap();
+            let prefix = prefix.downcast().unwrap();
+            let base_prefix = sys.getattr("base_prefix").unwrap();
+            let base_prefix = base_prefix.downcast().unwrap();
+            // Print them out or do whatever you want with them
+            println!("Python Version: {}", version.to_str().unwrap());
+            println!("Executable: {}", executable.to_str().unwrap());
+            println!("Prefix: {}", prefix.to_str().unwrap());
+            println!("Base Prefix: {}", base_prefix.to_str().unwrap());
+
+            let sys_path = sys.getattr("path").unwrap();
+            let sys_path = sys_path.downcast::<PyList>().unwrap();
+            println!("sys.path:");
+            for p in sys_path.iter() {
+                println!("  {}", p);
+            }
+
+            // If you need to check environment variables (e.g. VIRTUAL_ENV),
+            // you can import "os" and query os.environ:
+            let os = py.import("os").unwrap();
+            let environ = os.getattr("environ").unwrap();
+            let environ = environ.downcast::<PyMapping>().unwrap();
+            // If VIRTUAL_ENV is set, you can get it like:
+            if let Ok(environ) = environ.get_item("VIRTUAL_ENV") {
+                // if string
+                let virtual_env = environ.downcast::<PyString>();
+                if let Ok(virtual_env) = virtual_env {
+                    println!("VIRTUAL_ENV: {}", virtual_env);
+                } else {
+                    println!("VIRTUAL_ENV not set.");
+                }
+            } else {
+                println!("VIRTUAL_ENV not set.");
+            }
+
+            Ok::<_, String>(())
+        })
+        .unwrap();
+    }
+}

crates/cli/src/main.rs

@@ -18,6 +18,7 @@ use crate::docs::codegen_docs;
 
 mod commands;
 mod commands_fix;
+mod commands_info;
 mod commands_lint;
 #[cfg(feature = "codegen-docs")]
 mod docs;
@@ -93,6 +94,10 @@ fn main() {
             sqruff_lsp::run();
             0
         }
+        Commands::Info => {
+            commands_info::info();
+            0
+        }
     };
 
     std::process::exit(status_code);

crates/lib/Cargo.toml

@@ -21,6 +21,10 @@ doctest = false
 name = "rules"
 harness = false
 
+[[test]]
+name = "templaters"
+harness = false
+
 [[bench]]
 name = "parsing"
 harness = false
@@ -34,7 +38,7 @@ name = "depth_map"
 harness = false
 
 [features]
-python = ["pyo3"]
+python = ["pyo3", "sqruff-lib-core/serde"]
 
 [dependencies]
 sqruff-lib-core.workspace = true

crates/lib/src/core/linter/core.rs

@@ -53,16 +53,7 @@ impl Linter {
     ) -> Linter {
         let templater: &'static dyn Templater = match templater {
             Some(templater) => templater,
-            None => {
-                let templater_name = config.get("templater", "core").as_string();
-                match templater_name {
-                    Some(name) => match TEMPLATERS.into_iter().find(|t| t.name() == name) {
-                        Some(t) => t,
-                        None => panic!("Unknown templater: {}", name),
-                    },
-                    None => &RawTemplater,
-                }
-            }
+            None => Linter::get_templater(&config),
         };
         Linter {
             config,
@@ -73,6 +64,17 @@ impl Linter {
         }
     }
 
+    pub fn get_templater(config: &FluffConfig) -> &'static dyn Templater {
+        let templater_name = config.get("templater", "core").as_string();
+        match templater_name {
+            Some(name) => match TEMPLATERS.into_iter().find(|t| t.name() == name) {
+                Some(t) => t,
+                None => panic!("Unknown templater: {}", name),
+            },
+            None => &RawTemplater,
+        }
+    }
+
     /// Lint strings directly.
     pub fn lint_string_wrapped(
         &mut self,

crates/lib/src/templaters.rs

@@ -8,23 +8,35 @@ use crate::core::config::FluffConfig;
 use crate::templaters::placeholder::PlaceholderTemplater;
 use crate::templaters::raw::RawTemplater;
 
+#[cfg(feature = "python")]
+use crate::templaters::jinja::JinjaTemplater;
 #[cfg(feature = "python")]
 use crate::templaters::python::PythonTemplater;
 
+#[cfg(feature = "python")]
+pub mod jinja;
 pub mod placeholder;
 #[cfg(feature = "python")]
 pub mod python;
+#[cfg(feature = "python")]
+pub mod python_shared;
 pub mod raw;
 
 pub static RAW_TEMPLATER: RawTemplater = RawTemplater;
 pub static PLACEHOLDER_TEMPLATER: PlaceholderTemplater = PlaceholderTemplater;
 #[cfg(feature = "python")]
 pub static PYTHON_TEMPLATER: PythonTemplater = PythonTemplater;
+#[cfg(feature = "python")]
+pub static JINJA_TEMPLATER: JinjaTemplater = JinjaTemplater;
 
 // templaters returns all the templaters that are available in the library
 #[cfg(feature = "python")]
-pub static TEMPLATERS: [&'static dyn Templater; 3] =
-    [&RAW_TEMPLATER, &PLACEHOLDER_TEMPLATER, &PYTHON_TEMPLATER];
+pub static TEMPLATERS: [&'static dyn Templater; 4] = [
+    &RAW_TEMPLATER,
+    &PLACEHOLDER_TEMPLATER,
+    &PYTHON_TEMPLATER,
+    &JINJA_TEMPLATER,
+];
 
 #[cfg(not(feature = "python"))]
 pub static TEMPLATERS: [&'static dyn Templater; 2] = [&RAW_TEMPLATER, &PLACEHOLDER_TEMPLATER];