@frozenproductions/niteo 0.1.0

package/src/rules/no_mutable_exports.rs

@@ -0,0 +1,253 @@
+use std::path::Path;
+
+use crate::config::{RuleConfig, Severity};
+use crate::rules::Violation;
+
+const RULE_NAME: &str = "no-mutable-exports";
+const MESSAGE: &str = "Only export const, never export let.";
+
+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_export_let(bytes, cursor.index) => {
+                violations.push(mutable_export_violation(file, &cursor, config.severity));
+                advance_past_export_let(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 mutable_export_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_export_let(bytes: &[u8], index: usize) -> bool {
+    if !starts_keyword(bytes, index, b"export") {
+        return false;
+    }
+
+    let mut next_index = index + b"export".len();
+    next_index = skip_inline_whitespace(bytes, next_index);
+
+    if !starts_keyword(bytes, next_index, b"let") {
+        return false;
+    }
+
+    let after_let = next_index + b"let".len();
+    let next_byte = bytes.get(after_let).copied();
+    !is_identifier_byte(next_byte)
+}
+
+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 advance_past_export_let(bytes: &[u8], cursor: &mut Cursor) {
+    let target_index = cursor.index + b"export".len() + b"let".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_export_let() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "export let count = 0;\n",
+            &test_config(),
+        );
+
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].line, Some(1));
+        assert_eq!(violations[0].column, Some(1));
+    }
+
+    #[test]
+    fn reports_multiline_export_let() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "export\n  let count = 0;\n",
+            &test_config(),
+        );
+
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].line, Some(1));
+        assert_eq!(violations[0].column, Some(1));
+    }
+
+    #[test]
+    fn allows_export_const() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "export const count = 0;\n",
+            &test_config(),
+        );
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn allows_named_function_export() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "export function foo() {}\n",
+            &test_config(),
+        );
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn ignores_export_let_in_comments_and_strings() {
+        let source = r#"// export let count = 0;
+const text = "export let count = 0";
+/* export let count = 0; */
+"#;
+        let violations = check_file(Path::new("value.ts"), source, &test_config());
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn does_not_match_let_inside_expression() {
+        let source = r#"const exportLet = true;
+const value = "before export let after";
+"#;
+        let violations = check_file(Path::new("value.ts"), source, &test_config());
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn does_not_match_export_letting() {
+        let source = "export letting foo = 1;\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/no_upward_import.rs

@@ -0,0 +1,427 @@
+use std::path::Path;
+
+use crate::config::{Severity, UpwardImportRuleConfig};
+use crate::rules::Violation;
+
+const RULE_NAME: &str = "no-upward-import";
+const MESSAGE: &str = "Replace upward relative imports with local or project-root imports.";
+
+pub fn check_file(file: &Path, source: &str, config: &UpwardImportRuleConfig) -> 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_keyword(bytes, cursor.index, b"import") => {
+                if let Some(import_cursor) = parse_import_statement(bytes, cursor.index) {
+                    if should_report(import_cursor.specifier, config) {
+                        violations.push(violation(file, &cursor, config.severity));
+                    }
+                    advance_to(bytes, &mut cursor, import_cursor.next_index);
+                    continue;
+                }
+
+                cursor.advance(bytes);
+            }
+            _ if starts_keyword(bytes, cursor.index, b"export") => {
+                if let Some(export_cursor) = parse_export_statement(bytes, cursor.index) {
+                    if should_report(export_cursor.specifier, config) {
+                        violations.push(violation(file, &cursor, config.severity));
+                    }
+                    advance_to(bytes, &mut cursor, export_cursor.next_index);
+                    continue;
+                }
+
+                cursor.advance(bytes);
+            }
+            _ => 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;
+    }
+}
+
+struct ParsedModuleSpecifier<'a> {
+    specifier: &'a [u8],
+    next_index: usize,
+}
+
+fn parse_import_statement(bytes: &[u8], index: usize) -> Option<ParsedModuleSpecifier<'_>> {
+    let mut scanner = StatementScanner::new(bytes, index + b"import".len());
+    scanner.skip_whitespace();
+
+    if scanner.peek_byte() == Some(b'(') {
+        scanner.advance();
+        scanner.skip_whitespace();
+        let specifier = scanner.read_string_literal()?;
+        scanner.skip_whitespace();
+        if scanner.peek_byte() == Some(b')') {
+            scanner.advance();
+        }
+
+        return Some(ParsedModuleSpecifier {
+            specifier,
+            next_index: scanner.index,
+        });
+    }
+
+    if scanner.peek_byte() == Some(b'"')
+        || scanner.peek_byte() == Some(b'\'')
+        || scanner.peek_byte() == Some(b'`')
+    {
+        let specifier = scanner.read_string_literal()?;
+        return Some(ParsedModuleSpecifier {
+            specifier,
+            next_index: scanner.index,
+        });
+    }
+
+    if scanner.consume_keyword("type") {
+        scanner.skip_whitespace();
+    }
+
+    if scanner.skip_until_keyword("from") {
+        scanner.skip_whitespace();
+        let specifier = scanner.read_string_literal()?;
+        return Some(ParsedModuleSpecifier {
+            specifier,
+            next_index: scanner.index,
+        });
+    }
+
+    None
+}
+
+fn parse_export_statement(bytes: &[u8], index: usize) -> Option<ParsedModuleSpecifier<'_>> {
+    let mut scanner = StatementScanner::new(bytes, index + b"export".len());
+    scanner.skip_whitespace();
+
+    if scanner.consume_keyword("type") {
+        scanner.skip_whitespace();
+    }
+
+    if !(scanner.peek_byte() == Some(b'*') || scanner.peek_byte() == Some(b'{')) {
+        return None;
+    }
+
+    if scanner.skip_until_keyword("from") {
+        scanner.skip_whitespace();
+        let specifier = scanner.read_string_literal()?;
+        return Some(ParsedModuleSpecifier {
+            specifier,
+            next_index: scanner.index,
+        });
+    }
+
+    None
+}
+
+fn should_report(specifier: &[u8], config: &UpwardImportRuleConfig) -> bool {
+    upward_depth(specifier) > config.max_depth
+}
+
+fn upward_depth(specifier: &[u8]) -> usize {
+    specifier
+        .split(|byte| *byte == b'/')
+        .take_while(|segment| *segment == b"..")
+        .count()
+}
+
+fn 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 advance_to(bytes: &[u8], cursor: &mut Cursor, next_index: usize) {
+    while cursor.index < bytes.len() && cursor.index < next_index {
+        cursor.advance(bytes);
+    }
+}
+
+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_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;
+        }
+    }
+}
+
+#[derive(Debug)]
+struct StatementScanner<'a> {
+    source: &'a [u8],
+    index: usize,
+}
+
+impl<'a> StatementScanner<'a> {
+    fn new(source: &'a [u8], index: usize) -> Self {
+        Self { source, index }
+    }
+
+    fn advance(&mut self) {
+        self.index += 1;
+    }
+
+    fn skip_whitespace(&mut self) {
+        while matches!(
+            self.source.get(self.index),
+            Some(b' ' | b'\t' | b'\r' | b'\n')
+        ) {
+            self.advance();
+        }
+    }
+
+    fn peek_byte(&self) -> Option<u8> {
+        self.source.get(self.index).copied()
+    }
+
+    fn consume_keyword(&mut self, keyword: &str) -> bool {
+        if !starts_keyword(self.source, self.index, keyword.as_bytes()) {
+            return false;
+        }
+
+        self.index += keyword.len();
+        true
+    }
+
+    fn skip_until_keyword(&mut self, keyword: &str) -> bool {
+        while self.index < self.source.len() {
+            if starts_keyword(self.source, self.index, keyword.as_bytes()) {
+                self.index += keyword.len();
+                return true;
+            }
+
+            self.index += 1;
+        }
+
+        false
+    }
+
+    fn read_string_literal(&mut self) -> Option<&'a [u8]> {
+        let quote = self.peek_byte()?;
+        if !matches!(quote, b'\'' | b'"' | b'`') {
+            return None;
+        }
+
+        self.advance();
+        let start = self.index;
+        while self.index < self.source.len() {
+            let current = self.source[self.index];
+            if current == b'\\' {
+                self.index += 2;
+                continue;
+            }
+
+            if current == quote {
+                let end = self.index;
+                self.advance();
+                return Some(&self.source[start..end]);
+            }
+
+            self.index += 1;
+        }
+
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::check_file;
+    use crate::config::{Severity, UpwardImportRuleConfig};
+    use std::path::Path;
+
+    #[test]
+    fn reports_upward_relative_imports() {
+        let source = r#"import { shared } from "../../../shared";
+"#;
+        let violations = check_file(Path::new("Button.ts"), source, &test_config());
+
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].line, Some(1));
+        assert_eq!(violations[0].column, Some(1));
+    }
+
+    #[test]
+    fn reports_upward_relative_export_from() {
+        let source = r#"export { shared } from "../shared";
+"#;
+        let violations = check_file(Path::new("Button.ts"), source, &test_config());
+
+        assert_eq!(violations.len(), 1);
+    }
+
+    #[test]
+    fn reports_dynamic_upward_imports() {
+        let source = r#"const shared = await import("../../shared");
+"#;
+        let violations = check_file(Path::new("Button.ts"), source, &test_config());
+
+        assert_eq!(violations.len(), 1);
+    }
+
+    #[test]
+    fn keeps_line_positions_after_multiline_imports() {
+        let source = r#"import {
+  local,
+} from "./local";
+import { shared } from "../shared";
+"#;
+        let violations = check_file(Path::new("Button.ts"), source, &test_config());
+
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].line, Some(4));
+        assert_eq!(violations[0].column, Some(1));
+    }
+
+    #[test]
+    fn allows_same_folder_and_downward_imports() {
+        let source = r#"import { value } from "./value";
+export { other } from "./other";
+const shared = import("shared");
+"#;
+        let violations = check_file(Path::new("Button.ts"), source, &test_config());
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn does_not_treat_export_default_as_export_from() {
+        let source = r#"export default function Component() {}
+import { shared } from "../shared";
+"#;
+        let violations = check_file(Path::new("Button.ts"), source, &test_config());
+
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].line, Some(2));
+    }
+
+    #[test]
+    fn allows_configured_upward_depth() {
+        let source = r#"import { shared } from "../shared";
+import { other } from "../../other";
+"#;
+        let violations = check_file(Path::new("Button.ts"), source, &test_config_with_depth(1));
+
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].line, Some(2));
+    }
+
+    #[test]
+    fn ignores_comments_and_strings() {
+        let source = r#"// import { shared } from "../shared";
+const text = "export { shared } from '../shared'";
+/* import x from "../shared" */
+"#;
+        let violations = check_file(Path::new("Button.ts"), source, &test_config());
+
+        assert!(violations.is_empty());
+    }
+
+    fn test_config() -> UpwardImportRuleConfig {
+        UpwardImportRuleConfig {
+            severity: Severity::Warn,
+            max_depth: 0,
+        }
+    }
+
+    fn test_config_with_depth(max_depth: usize) -> UpwardImportRuleConfig {
+        UpwardImportRuleConfig {
+            max_depth,
+            ..test_config()
+        }
+    }
+}