Merge branch 'feature/55-indentation-rules' into feat/in2

jvsqzj · jvsqzj · commit 5ad18644845a · 2025-03-14T13:05:22.000-06:00
diff --git a/example_files/example_lint_cfg.json b/example_files/example_lint_cfg.json
@@ -6,8 +6,9 @@
     "nsp_unary": {},
     "nsp_trailing": {},
     "long_lines": { "max_length": 80 },
+    "in1": { "indentation_spaces": 4 },
     "in2": {},
-    "in3": { "indentation_spaces": 4 },
-    "continuation_line": { "indentation_spaces": 4 },
-    "in9": { "indentation_spaces": 4 }
+    "in3": {},
+    "in6": {},
+    "in9": {}
 }
diff --git a/src/lint/mod.rs b/src/lint/mod.rs
@@ -7,16 +7,18 @@ use rules::indentation::IN2Rule;
 use rules::{Rule, instantiate_rules, CurrentRules};
 use rules::{spacing::{SpBraceOptions, SpPunctOptions, NspFunparOptions,
                       NspInparenOptions, NspUnaryOptions, NspTrailingOptions},
-            indentation::{LongLineOptions, IN2Options, IN3Options,
-                          IN9Options, ContinuationLineOptions},
-            };
+                      indentation::{LongLineOptions, IN1Options, IN3Options,
+                                    IN2Options, IN9Options, IN6Options},
+                    };
 use crate::analysis::{DMLError, IsolatedAnalysis, LocalDMLError};
 use crate::analysis::parsing::tree::TreeElement;
 use crate::file_management::CanonPath;
 use crate::vfs::{Error, TextFile};
 use crate::analysis::parsing::structure::TopAst;
 use crate::lint::rules::indentation::{MAX_LENGTH_DEFAULT,
-                                      INDENTATION_LEVEL_DEFAULT};
+                                      INDENTATION_LEVEL_DEFAULT,
+                                      setup_indentation_size
+                                    };
 
 pub fn parse_lint_cfg(path: PathBuf) -> Result<LintCfg, String> {
     debug!("Reading Lint configuration from {:?}", path);
@@ -29,7 +31,10 @@ pub fn parse_lint_cfg(path: PathBuf) -> Result<LintCfg, String> {
 
 pub fn maybe_parse_lint_cfg(path: PathBuf) -> Option<LintCfg> {
     match parse_lint_cfg(path) {
-        Ok(cfg) => Some(cfg),
+        Ok(mut cfg) => {
+            setup_indentation_size(&mut cfg);
+            Some(cfg)
+        },
         Err(e) => {
             error!("Failed to parse linting CFG: {}", e);
             None
@@ -56,11 +61,13 @@ pub struct LintCfg {
     #[serde(default)]
     pub long_lines: Option<LongLineOptions>,
     #[serde(default)]
+    pub in1: Option<IN1Options>,
+    #[serde(default)]
     pub in2: Option<IN2Options>,
     #[serde(default)]
     pub in3: Option<IN3Options>,
     #[serde(default)]
-    pub continuation_line: Option<ContinuationLineOptions>,
+    pub in6: Option<IN6Options>,
     #[serde(default)]
     pub in9: Option<IN9Options>,
 }
@@ -74,15 +81,12 @@ impl Default for LintCfg {
             nsp_inparen: Some(NspInparenOptions{}),
             nsp_unary: Some(NspUnaryOptions{}),
             nsp_trailing: Some(NspTrailingOptions{}),
-            long_lines: Some(LongLineOptions {
-                max_length: MAX_LENGTH_DEFAULT,
-                            }),
+            long_lines: Some(LongLineOptions{max_length: MAX_LENGTH_DEFAULT}),
+            in1: Some(IN1Options{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
             in2: Some(IN2Options{}),
-            in3: Some(IN3Options{indentation_spaces: 4}),
-            continuation_line: Some(ContinuationLineOptions {
-                indentation_spaces: INDENTATION_LEVEL_DEFAULT,
-            }),
-            in9: Some(IN9Options{indentation_spaces: 4}),
+            in3: Some(IN3Options{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
+            in6: Some(IN6Options{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
+            in9: Some(IN9Options{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
         }
     }
 }
@@ -136,7 +140,7 @@ pub fn begin_style_check(ast: TopAst, file: String, rules: &CurrentRules) -> Res
     }
 
     // Continuation line check
-    rules.continuation_line.check(&mut linting_errors, &lines);
+    rules.in6.check(&mut linting_errors, &lines);
 
     post_process_linting_errors(&mut linting_errors);
 
diff --git a/src/lint/rules/indentation.rs b/src/lint/rules/indentation.rs
@@ -8,10 +8,31 @@ use crate::analysis::LocalDMLError;
 use crate::analysis::parsing::tree::{ZeroRange, Content, TreeElement};
 use serde::{Deserialize, Serialize};
 use super::Rule;
+use crate::lint::LintCfg;
 
 pub const MAX_LENGTH_DEFAULT: u32 = 80;
 pub const INDENTATION_LEVEL_DEFAULT: u32 = 4;
 
+fn default_indentation_spaces() -> u32 {
+    INDENTATION_LEVEL_DEFAULT
+}
+
+pub fn setup_indentation_size(cfg: &mut LintCfg) {
+    let mut indentation_spaces = INDENTATION_LEVEL_DEFAULT;
+
+    if let Some(in1) = &cfg.in1 {
+        indentation_spaces = in1.indentation_spaces;
+    }
+    if let Some(in3) = &mut cfg.in3 {
+        in3.indentation_spaces = indentation_spaces;
+    }
+    if let Some(in6) = &mut cfg.in6 {
+        in6.indentation_spaces = indentation_spaces;
+    }
+    if let Some(in9) = &mut cfg.in9 {
+        in9.indentation_spaces = indentation_spaces;
+    }
+}
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct LongLineOptions {
     pub max_length: u32,
@@ -29,7 +50,7 @@ impl LongLinesRule {
                 enabled: true,
                 max_length: long_lines.max_length,
             },
-            None => LongLinesRule { 
+            None => LongLinesRule {
                 enabled: false,
                 max_length: MAX_LENGTH_DEFAULT,
             },
@@ -59,6 +80,11 @@ impl Rule for LongLinesRule {
     }
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct IN1Options {
+    pub indentation_spaces: u32,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct IN2Options {}
 
@@ -98,8 +124,10 @@ pub struct IN3Rule {
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct IN3Options {
+    #[serde(default = "default_indentation_spaces")]
     pub indentation_spaces: u32,
 }
+
 pub struct IN3Args<'a> {
     members_ranges: Vec<ZeroRange>,
     lbrace: ZeroRange,
@@ -196,25 +224,26 @@ impl Rule for IN3Rule {
 
 // IN6: Continuation Line
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct ContinuationLineOptions {
+pub struct IN6Options {
+    #[serde(default = "default_indentation_spaces")]
     pub indentation_spaces: u32,
 }
 
-pub struct ContinuationLineRule {
+pub struct IN6Rule {
     pub enabled: bool,
     pub indentation_spaces: u32,
 }
 
-impl ContinuationLineRule {
-    pub fn from_options(options: &Option<ContinuationLineOptions>) -> ContinuationLineRule {
+impl IN6Rule {
+    pub fn from_options(options: &Option<IN6Options>) -> IN6Rule {
         match options {
-            Some(continuation_line) => ContinuationLineRule {
+            Some(in6) => IN6Rule {
                 enabled: true,
-                indentation_spaces: continuation_line.indentation_spaces,
+                indentation_spaces: in6.indentation_spaces,
             },
-            None => ContinuationLineRule {
+            None => IN6Rule {
                 enabled: false,
-                indentation_spaces: INDENTATION_LEVEL_DEFAULT,
+                indentation_spaces: 0,
             },
         }
     }
@@ -235,7 +264,7 @@ impl ContinuationLineRule {
             &logical_operators[..],
             &bitwise_operators[..],
         ];
-    
+
         for (i, line) in lines.iter().enumerate() {
             if let Some(last_char) = line.trim().chars().last() {
                 if operators.iter().any(|ops| ops.contains(&last_char.to_string().as_str())) {
@@ -244,7 +273,7 @@ impl ContinuationLineRule {
                         let expected_indent = line.chars().take_while(|c| c.is_whitespace()).count() + self.indentation_spaces as usize;
                         let actual_indent = next_line.chars().take_while(|c| c.is_whitespace()).count();
                         if actual_indent != expected_indent {
-                            let msg = ContinuationLineRule::description().to_owned();
+                            let msg = IN6Rule::description().to_owned();
                             let dmlerror = LocalDMLError {
                                 range: Range::new(
                                     Row::new_zero_indexed((i + 1) as u32),
@@ -263,13 +292,13 @@ impl ContinuationLineRule {
     }
 }
 
-impl Rule for ContinuationLineRule {
+impl Rule for IN6Rule {
     fn name() -> &'static str {
-        "CONTINUATION_LINE"
+        "IN6_CONTINUATION_LINE"
     }
 
     fn description() -> &'static str {
-        "Continuation line not indented correctly"
+        "Continuation line not indented correctly."
     }
 }
 
@@ -280,8 +309,10 @@ pub struct IN9Rule {
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct IN9Options {
+    #[serde(default = "default_indentation_spaces")]
     pub indentation_spaces: u32,
 }
+
 pub struct IN9Args<'a> {
     case_range: ZeroRange,
     expected_depth: &'a mut u32,
diff --git a/src/lint/rules/mod.rs b/src/lint/rules/mod.rs
@@ -7,7 +7,7 @@ pub mod tests;
 use spacing::{SpBracesRule,
     SpPunctRule, NspFunparRule, NspInparenRule,
     NspUnaryRule, NspTrailingRule};
-use indentation::{LongLinesRule, IN2Rule, IN3Rule, IN9Rule, ContinuationLineRule};
+use indentation::{LongLinesRule, IN2Rule, IN3Rule, IN6Rule, IN9Rule};
 use crate::lint::LintCfg;
 
 pub struct CurrentRules {
@@ -20,7 +20,7 @@ pub struct CurrentRules {
     pub long_lines: LongLinesRule,
     pub in2: IN2Rule,
     pub in3: IN3Rule,
-    pub continuation_line: ContinuationLineRule,
+    pub in6: IN6Rule,
     pub in9: IN9Rule
 }
 
@@ -35,7 +35,7 @@ pub fn  instantiate_rules(cfg: &LintCfg) -> CurrentRules {
         long_lines: LongLinesRule::from_options(&cfg.long_lines),
         in2: IN2Rule { enabled: cfg.in2.is_some() },
         in3: IN3Rule::from_options(&cfg.in3),
-        continuation_line: ContinuationLineRule::from_options(&cfg.continuation_line),
+        in6: IN6Rule::from_options(&cfg.in6),
         in9: IN9Rule::from_options(&cfg.in9),
     }
 }
