@frozenproductions/niteo 0.1.0

package/src/rules/no_default_export.rs

@@ -0,0 +1,241 @@
+use std::path::Path;
+
+use crate::config::{RuleConfig, Severity};
+use crate::rules::Violation;
+
+const RULE_NAME: &str = "no-default-export";
+const MESSAGE: &str = "Use named exports so imports stay explicit and refactorable.";
+
+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_default(bytes, cursor.index) => {
+                violations.push(default_export_violation(file, &cursor, config.severity));
+                advance_past_export_default(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 default_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_default(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);
+
+    starts_keyword(bytes, next_index, b"default")
+}
+
+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_default(bytes: &[u8], cursor: &mut Cursor) {
+    let target_index = cursor.index + b"export".len() + b"default".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_default_function_export() {
+        let violations = check_file(
+            Path::new("Component.tsx"),
+            "export default function Component() {}\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_default_value_export() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "const value = 1;\nexport default value;\n",
+            &test_config(),
+        );
+
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].line, Some(2));
+        assert_eq!(violations[0].column, Some(1));
+    }
+
+    #[test]
+    fn reports_multiline_default_export() {
+        let violations = check_file(
+            Path::new("value.ts"),
+            "export\n  default value;\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_named_exports() {
+        let violations = check_file(
+            Path::new("Component.tsx"),
+            "export function Component() {}\nexport { value } from './value';\n",
+            &test_config(),
+        );
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn ignores_export_default_in_comments_and_strings() {
+        let source = r#"// export default value;
+const text = "export default value";
+/* export default value; */
+"#;
+        let violations = check_file(Path::new("value.ts"), source, &test_config());
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn does_not_match_identifier_fragments() {
+        let source = r#"const exportDefault = true;
+const value = "before export default after";
+"#;
+        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_duplicate_file_names.rs

@@ -0,0 +1,196 @@
+use std::collections::HashMap;
+use std::path::Path;
+
+use crate::config::{NoDuplicateFileNamesRuleConfig, Severity};
+use crate::rules::Violation;
+
+const RULE_NAME: &str = "no-duplicate-file-names";
+const MESSAGE: &str = "Duplicate file names across directories are confusing in stack traces.";
+
+const DEFAULT_IGNORED_NAMES: &[&str] = &["index.ts", "index.tsx"];
+
+pub fn check_files(
+    files: &[std::path::PathBuf],
+    config: &NoDuplicateFileNamesRuleConfig,
+) -> Vec<Violation> {
+    let mut ignored = DEFAULT_IGNORED_NAMES
+        .iter()
+        .map(|s| s.to_string())
+        .collect::<Vec<_>>();
+    ignored.extend(config.ignore_names.clone());
+
+    let mut name_map: HashMap<String, Vec<std::path::PathBuf>> = HashMap::new();
+
+    for file in files {
+        if let Some(name) = file.file_name().and_then(|n| n.to_str()) {
+            if ignored.iter().any(|ign| name == *ign) {
+                continue;
+            }
+            name_map
+                .entry(name.to_string())
+                .or_default()
+                .push(file.clone());
+        }
+    }
+
+    let mut violations = Vec::new();
+
+    for (name, paths) in &name_map {
+        if paths.len() < 2 {
+            continue;
+        }
+
+        let duplicates = find_duplicates_in_different_dirs(paths);
+        if duplicates.is_empty() {
+            continue;
+        }
+
+        for (file_a, file_b) in &duplicates {
+            violations.push(duplicate_violation(file_a, file_b, name, config.severity));
+        }
+    }
+
+    violations
+}
+
+fn find_duplicates_in_different_dirs(
+    paths: &[std::path::PathBuf],
+) -> Vec<(std::path::PathBuf, std::path::PathBuf)> {
+    let mut pairs = Vec::new();
+
+    for i in 0..paths.len() {
+        for j in (i + 1)..paths.len() {
+            let dir_a = paths[i].parent();
+            let dir_b = paths[j].parent();
+
+            if let (Some(dir_a), Some(dir_b)) = (dir_a, dir_b) {
+                if dir_a != dir_b {
+                    pairs.push((paths[i].clone(), paths[j].clone()));
+                }
+            }
+        }
+    }
+
+    pairs
+}
+
+fn duplicate_violation(file: &Path, other: &Path, name: &str, severity: Severity) -> Violation {
+    Violation {
+        file: file.to_path_buf(),
+        line: None,
+        column: None,
+        rule: RULE_NAME,
+        message: MESSAGE,
+        severity,
+        detail: Some(format!("Also exists at: {}", other.display())),
+        subject: Some(name.to_string()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::check_files;
+    use crate::config::{NoDuplicateFileNamesRuleConfig, Severity};
+    use std::path::PathBuf;
+
+    #[test]
+    fn reports_duplicate_names_in_different_dirs() {
+        let files = vec![
+            PathBuf::from("src/components/Button.ts"),
+            PathBuf::from("src/utils/Button.ts"),
+        ];
+
+        let config = NoDuplicateFileNamesRuleConfig {
+            severity: Severity::Warn,
+            ignore_names: vec![],
+        };
+
+        let violations = check_files(&files, &config);
+
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].subject, Some("Button.ts".to_string()));
+    }
+
+    #[test]
+    fn ignores_same_name_in_same_dir() {
+        let files = vec![PathBuf::from("src/components/Button.ts")];
+
+        let config = NoDuplicateFileNamesRuleConfig {
+            severity: Severity::Warn,
+            ignore_names: vec![],
+        };
+
+        let violations = check_files(&files, &config);
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn ignores_index_files_by_default() {
+        let files = vec![
+            PathBuf::from("src/components/index.ts"),
+            PathBuf::from("src/utils/index.ts"),
+        ];
+
+        let config = NoDuplicateFileNamesRuleConfig {
+            severity: Severity::Warn,
+            ignore_names: vec![],
+        };
+
+        let violations = check_files(&files, &config);
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn respects_custom_ignore_names() {
+        let files = vec![
+            PathBuf::from("src/components/types.ts"),
+            PathBuf::from("src/utils/types.ts"),
+        ];
+
+        let config = NoDuplicateFileNamesRuleConfig {
+            severity: Severity::Warn,
+            ignore_names: vec!["types.ts".to_string()],
+        };
+
+        let violations = check_files(&files, &config);
+
+        assert!(violations.is_empty());
+    }
+
+    #[test]
+    fn reports_multiple_duplicate_pairs() {
+        let files = vec![
+            PathBuf::from("src/a/utils.ts"),
+            PathBuf::from("src/b/utils.ts"),
+            PathBuf::from("src/c/utils.ts"),
+        ];
+
+        let config = NoDuplicateFileNamesRuleConfig {
+            severity: Severity::Warn,
+            ignore_names: vec![],
+        };
+
+        let violations = check_files(&files, &config);
+
+        assert_eq!(violations.len(), 3);
+    }
+
+    #[test]
+    fn ignores_different_extensions() {
+        let files = vec![
+            PathBuf::from("src/components/Button.ts"),
+            PathBuf::from("src/utils/Button.tsx"),
+        ];
+
+        let config = NoDuplicateFileNamesRuleConfig {
+            severity: Severity::Warn,
+            ignore_names: vec![],
+        };
+
+        let violations = check_files(&files, &config);
+
+        assert!(violations.is_empty());
+    }
+}