temp [ci skip]

benfdking · benfdking · commit ee4d4f87da68 · 2025-02-13T12:13:41.000Z
diff --git a/crates/lib-core/src/parser/segments/base.rs b/crates/lib-core/src/parser/segments/base.rs
@@ -139,6 +139,11 @@ impl ErasedSegment {
         }
     }
 
+    /// Return true if this segment has no children
+    pub fn is_raw(&self) -> bool {
+        self.segments().is_empty()
+    }
+
     pub fn segments(&self) -> &[ErasedSegment] {
         match &self.value.kind {
             NodeOrTokenKind::Node(node) => &node.segments,
diff --git a/crates/lib-core/src/templaters/base.rs b/crates/lib-core/src/templaters/base.rs
@@ -233,6 +233,10 @@ impl TemplatedFileInner {
         self.templated_str.is_some()
     }
 
+    pub fn raw_sliced_iter(&self) -> impl Iterator<Item = &RawFileSlice> {
+        self.raw_sliced.iter()
+    }
+
     /// Get the line number and position of a point in the source file.
     /// Args:
     ///  - char_pos: The character position in the relevant file.
@@ -540,8 +544,8 @@ pub enum RawFileSliceType {
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub struct RawFileSlice {
     /// Source string
-    raw: String,
-    pub(crate) slice_type: String,
+    pub raw: String,
+    pub slice_type: String,
     /// Offset from beginning of source string
     pub source_idx: usize,
     slice_subtype: Option<RawFileSliceType>,
diff --git a/crates/lib/src/rules/jinja.rs b/crates/lib/src/rules/jinja.rs
@@ -1,7 +1,9 @@
+use crate::core::rules::base::ErasedRule;
+
 pub mod jj01;
 
 pub fn rules() -> Vec<ErasedRule> {
     use crate::core::rules::base::Erased as _;
 
-    vec![jj01::RuleJJ01::default().erased()]
+    vec![jj01::RuleJJ01.erased()]
 }
diff --git a/crates/lib/src/rules/jinja/jj01.rs b/crates/lib/src/rules/jinja/jj01.rs
@@ -1,12 +1,12 @@
 use ahash::AHashMap;
-use sqruff_lib_core::dialects::syntax::{SyntaxKind, SyntaxSet};
-use sqruff_lib_core::parser::segments::base::SegmentBuilder;
+use sqruff_lib_core::lint_fix::LintFix;
+use sqruff_lib_core::parser::segments::base::ErasedSegment;
+use sqruff_lib_core::parser::segments::fix::SourceFix;
 
 use crate::core::config::Value;
 use crate::core::rules::base::{Erased, ErasedRule, LintResult, Rule, RuleGroups};
 use crate::core::rules::context::RuleContext;
-use crate::core::rules::crawlers::{Crawler, SegmentSeekerCrawler};
-use crate::utils::reflow::sequence::{Filter, ReflowInsertPosition, ReflowSequence, TargetSide};
+use crate::core::rules::crawlers::{Crawler, RootOnlyCrawler};
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum Aliasing {
@@ -15,12 +15,11 @@ pub enum Aliasing {
 }
 
 #[derive(Debug, Clone)]
-pub struct RuleJJ01 {
-}
+pub struct RuleJJ01;
 
 impl Rule for RuleJJ01 {
     fn load_from_config(&self, _config: &AHashMap<String, Value>) -> Result<ErasedRule, String> {
-        Ok()
+        Ok(RuleJJ01.erased())
     }
 
     fn name(&self) -> &'static str {
@@ -54,19 +53,178 @@ SELECT {{ a }} from {{
 "#
     }
 
+
     fn groups(&self) -> &'static [RuleGroups] {
         &[RuleGroups::All, RuleGroups::Jinja]
     }
 
-    fn eval(&self, rule_cx: &RuleContext) -> Vec<LintResult> {
-        unimplemented!()
+    fn eval(&self, context: &RuleContext) -> Vec<LintResult> {
+        debug_assert!(context.segment.get_position_marker().is_some());
+        
+        // If the position marker for the root segment is literal then there's
+        // no templated code, so return early
+        if context.segment.get_position_marker().unwrap().is_literal() {
+            return vec![];
+        }
+
+        // Need templated file to proceed
+        let Some(templated_file) = &context.templated_file else {
+            return vec![];
+        };
+
+        let mut results: Vec<LintResult> = vec![];
+
+        // Work through the templated slices
+        for raw_slice in templated_file.raw_sliced_iter() {
+            // Only want templated slices
+            if !matches!(raw_slice.slice_type.as_str(), "templated" | "block_start" | "block_end") {
+                continue;
+            }
+
+            let stripped = raw_slice.raw.trim();
+            if stripped.is_empty() || !stripped.starts_with('{') || !stripped.ends_with('}') {
+                continue;
+            }
+
+            // Partition and position
+            let src_idx = raw_slice.source_idx;
+            let (tag_pre, ws_pre, inner, ws_post, tag_post) = Self::get_white_space_ends(stripped.to_string());
+            let position = raw_slice.raw.find(stripped.chars().next().unwrap()).unwrap_or(0);
+
+            // Whitespace should be single space OR contain newline
+            let mut pre_fix = None;
+            let mut post_fix = None;
+
+            if ws_pre.is_empty() || (ws_pre != " " && !ws_pre.contains('\n')) {
+                pre_fix = Some(" ");
+            }
+            if ws_post.is_empty() || (ws_post != " " && !ws_post.contains('\n')) {
+                post_fix = Some(" ");
+            }
+
+            // Skip if no fixes needed
+            if pre_fix.is_none() && post_fix.is_none() {
+                continue;
+            }
+
+            let fixed = format!(
+                "{}{}{}{}{}",
+                tag_pre,
+                pre_fix.unwrap_or(&ws_pre),
+                inner,
+                post_fix.unwrap_or(&ws_post),
+                tag_post
+            );
+
+            // Find raw segment to attach fix to
+            let Some(raw_seg) = Self::find_raw_at_src_index(context.segment.clone(), src_idx) else {
+                continue;
+            };
+
+            // Skip if segment already has fixes
+            if !raw_seg.get_source_fixes().is_empty() {
+                continue;
+            }
+
+            let source_fixes = vec![LintFix::replace(
+                raw_seg.clone(),
+                vec![],
+                Some(vec![SourceFix::new(
+                    fixed.into(),
+                    src_idx + position..src_idx + position + stripped.len(),
+                    // This position in the templated file is rough, but close enough for sequencing.
+                    raw_seg.get_position_marker().unwrap().templated_slice.clone(),
+                ).erased()]),
+            )];
+
+            results.push(LintResult::new(
+                Some(raw_seg.clone()),
+                source_fixes,
+                Some(format!("Jinja tags should have a single whitespace on either side: {}", stripped)),
+                None,
+            ));
+        }
+
+        //     results.push(LintResult::new(
+        //         Some(raw_seg.clone()),
+        //         vec![LintFix::replace(
+        //             raw_seg,
+        //             [raw_seg.edit(source_fixes)],
+        //             None,
+        //         )],
+        //         Some(format!("Jinja tags should have a single whitespace on either side: {}", stripped)),
+        //         raw_seg.get_position_marker().unwrap().source_slice,
+        //     ));
+        // }
+        // results
+
+        unimplemented!();
     }
 
     fn is_fix_compatible(&self) -> bool {
         true
     }
 
     fn crawl_behaviour(&self) -> Crawler {
-        SegmentSeekerCrawler::new(const { SyntaxSet::new(&[SyntaxKind::AliasExpression]) }).into()
-    }
+        RootOnlyCrawler.into()
+        }
 }
+
+impl RuleJJ01 {
+    fn get_white_space_ends(s: String) -> (String, String, String, String, String) {
+        assert!(s.starts_with('{') && s.ends_with('}'), "String must start with {{ and end with }}");
+
+        // Get the main content between the tag markers
+        let mut main = s[2..s.len()-2].to_string();
+        let mut pre = s[..2].to_string();
+        let mut post = s[s.len()-2..].to_string();
+
+        // Handle plus/minus modifiers
+        let modifier_chars = ['+', '-'];
+        if !main.is_empty() && modifier_chars.contains(&main.chars().next().unwrap()) {
+            main = main[1..].to_string();
+            pre = s[..3].to_string();
+        }
+        if !main.is_empty() && modifier_chars.contains(&main.chars().last().unwrap()) {
+            main = main[..main.len()-1].to_string();
+            post = s[s.len()-3..].to_string();
+        }
+
+        // Split out inner content and surrounding whitespace
+        let inner = main.trim().to_string();
+        let pos = main.find(&inner).unwrap_or(0);
+        let pre_ws = main[..pos].to_string();
+        let post_ws = main[pos + inner.len()..].to_string();
+
+        (pre, pre_ws, inner, post_ws, post)
+    }
+
+    fn find_raw_at_src_index(segment: ErasedSegment, src_idx: usize) -> Option<ErasedSegment> {
+        // Recursively search to find a raw segment for a position in the source.
+        // NOTE: This assumes it's not being called on a `raw`.
+        // In the case that there are multiple potential targets, we will find the first.
+        assert!(!segment.is_raw(), "Segment must not be raw");
+        let segments = segment.segments();
+        assert!(segments.len() > 0, "Segment must have segments");
+
+        for seg in segments {
+            if let Some(pos_marker) = seg.get_position_marker() {
+                let src_slice = pos_marker.source_slice.clone();
+                
+                // If it's before, skip onward
+                if src_slice.end <= src_idx {
+                    continue;
+                }
+
+                // Is the current segment raw?
+                if seg.is_raw() {
+                    return Some(seg.clone());
+                }
+
+                // Otherwise recurse
+                return Self::find_raw_at_src_index(seg.clone(), src_idx);
+            }
+        }
+        None
+    }
+}
diff --git a/crates/lib/test/fixtures/rules/std_rule_cases/JJ01.yml b/crates/lib/test/fixtures/rules/std_rule_cases/JJ01.yml
@@ -0,0 +1,70 @@
+rule: JJ01
+
+test_simple:
+  pass_str: SELECT 1 from {{ ref('foo') }}
+
+test_simple_modified:
+  # Test that the plus/minus notation works fine.
+  pass_str: SELECT 1 from {%+ if true -%} foo {%- endif %}
+
+test_simple_modified_fail:
+  # Test that the plus/minus notation works fine.
+  fail_str: SELECT 1 from {%+if true-%} {{ref('foo')}} {%-endif%}
+  fix_str: SELECT 1 from {%+ if true -%} {{ ref('foo') }} {%- endif %}
+
+test_fail_jinja_tags_no_space:
+  fail_str: SELECT 1 from {{ref('foo')}}
+  fix_str: SELECT 1 from {{ ref('foo') }}
+
+test_fail_jinja_tags_multiple_spaces:
+  fail_str: SELECT 1 from {{      ref('foo')       }}
+  fix_str: SELECT 1 from {{ ref('foo') }}
+
+test_fail_jinja_tags_no_space_2:
+  fail_str: SELECT 1 from {{+ref('foo')-}}
+  fix_str: SELECT 1 from {{+ ref('foo') -}}
+
+test_pass_newlines:
+  # It's ok if there are newlines.
+  pass_str:
+    SELECT 1 from {{
+      ref('foo')
+    }}
+
+test_fail_templated_segment_contains_leading_literal:
+  fail_str: |
+    SELECT user_id
+    FROM
+        `{{"gcp_project"}}.{{"dataset"}}.campaign_performance`
+  fix_str: |
+    SELECT user_id
+    FROM
+        `{{ "gcp_project" }}.{{ "dataset" }}.campaign_performance`
+  configs:
+    core:
+      dialect: bigquery
+
+test_fail_segment_contains_multiple_templated_slices_last_one_bad:
+  fail_str: CREATE TABLE `{{ "project" }}.{{ "dataset" }}.{{"table"}}`
+  fix_str: CREATE TABLE `{{ "project" }}.{{ "dataset" }}.{{ "table" }}`
+  configs:
+    core:
+      dialect: bigquery
+
+test_fail_jinja_tags_no_space_no_content:
+  fail_str: SELECT {{""-}}1
+  fix_str: SELECT {{ "" -}}1
+
+test_fail_jinja_tags_across_segment_boundaries:
+  fail_str: SELECT a{{-"1 + b"}}2
+  fix_str: SELECT a{{- "1 + b" }}2
+
+test_pass_python_templater:
+  pass_str: SELECT * FROM hello.{my_table};
+  configs:
+    core:
+      templater: python
+    templater:
+      python:
+        context:
+          my_table: foo

Original file line number	Diff line number	Diff line change
`@@ -139,6 +139,11 @@ impl ErasedSegment {`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`
	`142`	`+ /// Return true if this segment has no children`
	`143`	`+ pub fn is_raw(&self) -> bool {`
	`144`	`+ self.segments().is_empty()`
	`145`	`+ }`
	`146`	`+`
`142`	`147`	`pub fn segments(&self) -> &[ErasedSegment] {`
`143`	`148`	`match &self.value.kind {`
`144`	`149`	`NodeOrTokenKind::Node(node) => &node.segments,`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,9 @@`
	`1`	`+use crate::core::rules::base::ErasedRule;`
	`2`	`+`
`1`	`3`	`pub mod jj01;`
`2`	`4`
`3`	`5`	`pub fn rules() -> Vec<ErasedRule> {`
`4`	`6`	`use crate::core::rules::base::Erased as _;`
`5`	`7`
`6`		`- vec![jj01::RuleJJ01::default().erased()]`
	`8`	`+ vec![jj01::RuleJJ01.erased()]`
`7`	`9`	`}`