@frozenproductions/niteo 0.1.0

package/src/rules/prefer_satisfies.rs

@@ -0,0 +1,319 @@
+use std::path::Path;
+
+use crate::config::{RuleConfig, Severity};
+use crate::rules::Violation;
+
+const RULE_NAME: &str = "prefer-satisfies";
+const MESSAGE: &str =
+    "Prefer 'satisfies' over 'as' for type validation without changing the inferred type.";
+
+pub fn check_file(file: &Path, source: &str, config: &RuleConfig) -> Vec<Violation> {
+    let bytes = source.as_bytes();
+    let mut violations = Vec::new();
+    let mut cursor = Cursor::default();
+    let mut string_quote: Option<u8> = None;
+
+    while cursor.index < bytes.len() {
+        let current = bytes[cursor.index];
+        let next = bytes.get(cursor.index + 1).copied();
+
+        if let Some(quote) = string_quote {
+            if current == b'\\' {
+                cursor.advance(bytes);
+                if cursor.index < bytes.len() {
+                    cursor.advance(bytes);
+                }
+                continue;
+            }
+
+            if current == quote {
+                string_quote = None;
+            }
+
+            cursor.advance(bytes);
+            continue;
+        }
+
+        match (current, next) {
+            (b'\'', _) | (b'"', _) | (b'`', _) => {
+                string_quote = Some(current);
+                cursor.advance(bytes);
+            }
+            (b'/', Some(b'/')) => skip_line_comment(bytes, &mut cursor),
+            (b'/', Some(b'*')) => skip_block_comment(bytes, &mut cursor),
+            _ if starts_as_cast(bytes, cursor.index) => {
+                if should_prefer_satisfies(bytes, cursor.index) {
+                    violations.push(as_cast_violation(file, &cursor, config.severity));
+                }
+                advance_past_as(bytes, &mut cursor);
+            }
+            _ => cursor.advance(bytes),
+        }
+    }
+
+    violations
+}
+
+#[derive(Debug, Clone, Copy)]
+struct Cursor {
+    index: usize,
+    line: usize,
+    column: usize,
+}
+
+impl Default for Cursor {
+    fn default() -> Self {
+        Self {
+            index: 0,
+            line: 1,
+            column: 1,
+        }
+    }
+}
+
+impl Cursor {
+    fn advance(&mut self, bytes: &[u8]) {
+        if bytes[self.index] == b'\n' {
+            self.line += 1;
+            self.column = 1;
+        } else {
+            self.column += 1;
+        }
+
+        self.index += 1;
+    }
+}
+
+fn as_cast_violation(file: &Path, cursor: &Cursor, severity: Severity) -> Violation {
+    Violation {
+        file: file.to_path_buf(),
+        line: Some(cursor.line),
+        column: Some(cursor.column),
+        rule: RULE_NAME,
+        message: MESSAGE,
+        severity,
+        detail: None,
+        subject: None,
+    }
+}
+
+fn starts_as_cast(bytes: &[u8], index: usize) -> bool {
+    if !starts_keyword(bytes, index, b"as") {
+        return false;
+    }
+
+    let after_as = index + b"as".len();
+    let next_byte = bytes.get(after_as).copied();
+    !is_identifier_byte(next_byte)
+}
+
+fn should_prefer_satisfies(bytes: &[u8], as_index: usize) -> bool {
+    let after_as = as_index + b"as".len();
+    let next_index = skip_inline_whitespace(bytes, after_as);
+
+    if starts_keyword(bytes, next_index, b"const")
+        || starts_keyword(bytes, next_index, b"any")
+        || starts_keyword(bytes, next_index, b"unknown")
+    {
+        return false;
+    }
+
+    let before_as = as_index.wrapping_sub(1);
+    let prev_index = skip_trailing_whitespace(bytes, before_as);
+
+    matches!(
+        bytes.get(prev_index).copied(),
+        Some(b'}') | Some(b']') | Some(b'"') | Some(b'\'') | Some(b'`') | Some(b'0'..=b'9')
+    )
+}
+
+fn starts_keyword(bytes: &[u8], index: usize, keyword: &[u8]) -> bool {
+    bytes.get(index..index + keyword.len()) == Some(keyword)
+        && !is_identifier_byte(bytes.get(index.wrapping_sub(1)).copied())
+        && !is_identifier_byte(bytes.get(index + keyword.len()).copied())
+}
+
+fn is_identifier_byte(byte: Option<u8>) -> bool {
+    matches!(
+        byte,
+        Some(b'a'..=b'z') | Some(b'A'..=b'Z') | Some(b'0'..=b'9') | Some(b'_') | Some(b'$')
+    )
+}
+
+fn skip_inline_whitespace(bytes: &[u8], mut index: usize) -> usize {
+    while matches!(bytes.get(index), Some(b' ' | b'\t' | b'\r' | b'\n')) {
+        index += 1;
+    }
+
+    index
+}
+
+fn skip_trailing_whitespace(bytes: &[u8], mut index: usize) -> usize {
+    while index > 0 && matches!(bytes.get(index), Some(b' ' | b'\t' | b'\r' | b'\n')) {
+        index -= 1;
+    }
+
+    index
+}
+
+fn advance_past_as(bytes: &[u8], cursor: &mut Cursor) {
+    let target_index = cursor.index + b"as".len();
+    while cursor.index < bytes.len() && cursor.index < target_index {
+        cursor.advance(bytes);
+    }
+}
+
+fn skip_line_comment(bytes: &[u8], cursor: &mut Cursor) {
+    while cursor.index < bytes.len() && bytes[cursor.index] != b'\n' {
+        cursor.advance(bytes);
+    }
+}
+
+fn skip_block_comment(bytes: &[u8], cursor: &mut Cursor) {
+    cursor.advance(bytes);
+    cursor.advance(bytes);
+
+    while cursor.index < bytes.len() {
+        let current = bytes[cursor.index];
+        let next = bytes.get(cursor.index + 1).copied();
+
+        cursor.advance(bytes);
+
+        if current == b'*' && next == Some(b'/') {
+            cursor.advance(bytes);
+            break;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::check_file;
+    use crate::config::{RuleConfig, Severity};
+    use std::path::Path;
+
+    #[test]
+    fn reports_object_literal_as_cast() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "const config = { port: 3000 } as Config;\n",
+            &test_config(),
+        );
+
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].line, Some(1));
+    }
+
+    #[test]
+    fn reports_array_literal_as_cast() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "const items = [1, 2, 3] as number[];\n",
+            &test_config(),
+        );
+
+        assert_eq!(violations.len(), 1);
+    }
+
+    #[test]
+    fn reports_string_literal_as_cast() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "const event = \"click\" as EventName;\n",
+            &test_config(),
+        );
+
+        assert_eq!(violations.len(), 1);
+    }
+
+    #[test]
+    fn reports_numeric_literal_as_cast() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "const code = 404 as StatusCode;\n",
+            &test_config(),
+        );
+
+        assert_eq!(violations.len(), 1);
+    }
+
+    #[test]
+    fn allows_as_const() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "const config = { port: 3000 } as const;\n",
+            &test_config(),
+        );
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn allows_as_any() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "const value = something as any;\n",
+            &test_config(),
+        );
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn allows_as_unknown() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "const value = something as unknown as Target;\n",
+            &test_config(),
+        );
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn allows_variable_as_cast() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "const value = someVar as Target;\n",
+            &test_config(),
+        );
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn allows_function_call_as_cast() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "const result = getData() as Response;\n",
+            &test_config(),
+        );
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn ignores_as_in_comments_and_strings() {
+        let source = r#"// const x = {} as Config;
+const text = "as Config";
+/* const x = {} as Config; */
+"#;
+        let violations = check_file(Path::new("value.ts"), source, &test_config());
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn does_not_match_as_in_identifier() {
+        let source = "const task = 'hello';\n";
+        let violations = check_file(Path::new("value.ts"), source, &test_config());
+
+        assert!(violations.is_empty());
+    }
+
+    fn test_config() -> RuleConfig {
+        RuleConfig {
+            severity: Severity::Warn,
+        }
+    }
+}

package/src/rules.rs

@@ -0,0 +1,247 @@
+mod max_directory_depth;
+mod max_file_exports;
+mod max_items_per_directory;
+mod min_items_per_directory;
+mod no_barrel_files;
+mod no_comments;
+mod no_console;
+mod no_debugger;
+mod no_default_export;
+mod no_duplicate_file_names;
+mod no_empty_directories;
+mod no_empty_interface;
+mod no_enums;
+mod no_eval;
+mod no_export_star;
+mod no_inline_types;
+mod no_interface;
+mod no_large_file;
+mod no_logic_in_barrel;
+mod no_logic_in_domain;
+mod no_mutable_exports;
+mod no_upward_import;
+mod prefer_satisfies;
+
+use anyhow::{Context, Result};
+use std::fs;
+use std::path::PathBuf;
+
+use crate::config::{
+    CommentsRuleConfig, FileExportsRuleConfig, FileLengthRuleConfig, MaxDirectoryDepthRuleConfig,
+    MaxItemsPerDirectoryRuleConfig, MinItemsPerDirectoryRuleConfig, NoConsoleRuleConfig,
+    NoDuplicateFileNamesRuleConfig, NoEmptyDirectoriesRuleConfig, NoInterfaceRuleConfig,
+    NoLogicInDomainRuleConfig, RuleConfig, Severity, UpwardImportRuleConfig,
+};
+
+#[derive(Debug, Clone)]
+pub struct Violation {
+    pub file: PathBuf,
+    pub line: Option<usize>,
+    pub column: Option<usize>,
+    pub rule: &'static str,
+    pub message: &'static str,
+    pub severity: Severity,
+    pub detail: Option<String>,
+    pub subject: Option<String>,
+}
+
+pub fn check_files(
+    files: &[PathBuf],
+    no_comments: CommentsRuleConfig,
+    no_logic_in_barrel: RuleConfig,
+    no_default_export: RuleConfig,
+    no_export_star: RuleConfig,
+    no_inline_types: RuleConfig,
+    max_file_exports: FileExportsRuleConfig,
+    no_upward_import: UpwardImportRuleConfig,
+    no_large_file: FileLengthRuleConfig,
+    no_enums: RuleConfig,
+    no_barrel_files: RuleConfig,
+    no_console: NoConsoleRuleConfig,
+    no_debugger: RuleConfig,
+    no_eval: RuleConfig,
+    no_logic_in_domain: NoLogicInDomainRuleConfig,
+    no_empty_interface: RuleConfig,
+    no_interface: NoInterfaceRuleConfig,
+    no_mutable_exports: RuleConfig,
+    prefer_satisfies: RuleConfig,
+) -> Result<Vec<Violation>> {
+    let mut violations = Vec::new();
+
+    if !no_comments.severity.is_enabled()
+        && !no_logic_in_barrel.severity.is_enabled()
+        && !no_default_export.severity.is_enabled()
+        && !no_export_star.severity.is_enabled()
+        && !no_inline_types.severity.is_enabled()
+        && !max_file_exports.severity.is_enabled()
+        && !no_upward_import.severity.is_enabled()
+        && !no_large_file.severity.is_enabled()
+        && !no_enums.severity.is_enabled()
+        && !no_barrel_files.severity.is_enabled()
+        && !no_console.severity.is_enabled()
+        && !no_debugger.severity.is_enabled()
+        && !no_eval.severity.is_enabled()
+        && !no_logic_in_domain.severity.is_enabled()
+        && !no_empty_interface.severity.is_enabled()
+        && !no_interface.severity.is_enabled()
+        && !no_mutable_exports.severity.is_enabled()
+        && !prefer_satisfies.severity.is_enabled()
+    {
+        return Ok(violations);
+    }
+
+    let type_location_style = no_inline_types::TypeLocationStyle::detect(files);
+
+    for file in files {
+        let source = fs::read_to_string(file)
+            .with_context(|| format!("failed to read {}", file.display()))?;
+        if no_comments.severity.is_enabled() {
+            violations.extend(no_comments::check_file(file, &source, &no_comments));
+        }
+        if no_logic_in_barrel.severity.is_enabled() {
+            violations.extend(no_logic_in_barrel::check_file(
+                file,
+                &source,
+                &no_logic_in_barrel,
+            ));
+        }
+        if no_default_export.severity.is_enabled() {
+            violations.extend(no_default_export::check_file(
+                file,
+                &source,
+                &no_default_export,
+            ));
+        }
+        if no_export_star.severity.is_enabled() {
+            violations.extend(no_export_star::check_file(file, &source, &no_export_star));
+        }
+        if no_inline_types.severity.is_enabled() {
+            violations.extend(no_inline_types::check_file(
+                file,
+                &source,
+                &no_inline_types,
+                type_location_style,
+            ));
+        }
+        if max_file_exports.severity.is_enabled() {
+            violations.extend(max_file_exports::check_file(
+                file,
+                &source,
+                &max_file_exports,
+            ));
+        }
+        if no_upward_import.severity.is_enabled() {
+            violations.extend(no_upward_import::check_file(
+                file,
+                &source,
+                &no_upward_import,
+            ));
+        }
+        if no_large_file.severity.is_enabled() {
+            violations.extend(no_large_file::check_file(file, &source, &no_large_file));
+        }
+        if no_enums.severity.is_enabled() {
+            violations.extend(no_enums::check_file(file, &source, &no_enums));
+        }
+        if no_barrel_files.severity.is_enabled() {
+            violations.extend(no_barrel_files::check_file(file, &source, &no_barrel_files));
+        }
+        if no_console.severity.is_enabled() {
+            violations.extend(no_console::check_file(file, &source, &no_console));
+        }
+        if no_debugger.severity.is_enabled() {
+            violations.extend(no_debugger::check_file(file, &source, &no_debugger));
+        }
+        if no_eval.severity.is_enabled() {
+            violations.extend(no_eval::check_file(file, &source, &no_eval));
+        }
+        if no_logic_in_domain.severity.is_enabled() {
+            violations.extend(no_logic_in_domain::check_file(
+                file,
+                &source,
+                &no_logic_in_domain,
+            ));
+        }
+        if no_empty_interface.severity.is_enabled() {
+            violations.extend(no_empty_interface::check_file(
+                file,
+                &source,
+                &no_empty_interface,
+            ));
+        }
+        if no_interface.severity.is_enabled() {
+            violations.extend(no_interface::check_file(file, &source, &no_interface));
+        }
+        if no_mutable_exports.severity.is_enabled() {
+            violations.extend(no_mutable_exports::check_file(
+                file,
+                &source,
+                &no_mutable_exports,
+            ));
+        }
+        if prefer_satisfies.severity.is_enabled() {
+            violations.extend(prefer_satisfies::check_file(
+                file,
+                &source,
+                &prefer_satisfies,
+            ));
+        }
+    }
+
+    Ok(violations)
+}
+
+pub fn check_directories(
+    root: &std::path::Path,
+    no_empty_directories: NoEmptyDirectoriesRuleConfig,
+) -> Vec<Violation> {
+    if !no_empty_directories.severity.is_enabled() {
+        return Vec::new();
+    }
+
+    no_empty_directories::check_directories(root, &no_empty_directories)
+}
+
+pub fn check_duplicate_file_names(
+    files: &[PathBuf],
+    no_duplicate_file_names: NoDuplicateFileNamesRuleConfig,
+) -> Vec<Violation> {
+    if !no_duplicate_file_names.severity.is_enabled() {
+        return Vec::new();
+    }
+
+    no_duplicate_file_names::check_files(files, &no_duplicate_file_names)
+}
+
+pub fn check_max_items_per_directory(
+    root: &std::path::Path,
+    config: MaxItemsPerDirectoryRuleConfig,
+) -> Vec<Violation> {
+    if !config.severity.is_enabled() {
+        return Vec::new();
+    }
+
+    max_items_per_directory::check_directories(root, &config)
+}
+
+pub fn check_min_items_per_directory(
+    root: &std::path::Path,
+    config: MinItemsPerDirectoryRuleConfig,
+) -> Vec<Violation> {
+    if !config.severity.is_enabled() {
+        return Vec::new();
+    }
+
+    min_items_per_directory::check_directories(root, &config)
+}
+
+pub fn check_max_directory_depth(
+    root: &std::path::Path,
+    config: MaxDirectoryDepthRuleConfig,
+) -> Vec<Violation> {
+    if !config.severity.is_enabled() {
+        return Vec::new();
+    }
+
+    max_directory_depth::check_directories(root, &config)
+}