jsxbin-analyzer 1.0.0

Comprehensive code analyzer for JSX with dependency detection, API classification, and security scanning
Documentation
use crate::types::StringAnalysis;
use jsxbin_parser::types::Token;
use log::{debug, trace};
use regex::Regex;
use std::collections::HashMap;

/// Extracts and analyzes string literals from code
pub struct StringExtractor {
    path_regex: Regex,
    url_regex: Regex,
    email_regex: Regex,
}

impl StringExtractor {
    /// Create a new string extractor
    pub fn new() -> Self {
        StringExtractor {
            // Matches file paths: /path/to/file or C:\path\to\file
            path_regex: Regex::new(r#"[/\\][\w./\\-]+"#).unwrap(),

            // Matches URLs: http://... or https://...
            url_regex: Regex::new(r#"https?://[^\s]+"#).unwrap(),

            // Matches email addresses
            email_regex: Regex::new(r#"[\w\.-]+@[\w\.-]+\.\w+"#).unwrap(),
        }
    }

    /// Extract strings from tokens
    pub fn extract_from_tokens(&self, tokens: &[Token]) -> Vec<StringAnalysis> {
        debug!("Extracting strings from tokens");
        let mut strings = HashMap::new();

        for token in tokens {
            if let Token::StringLiteral(s) = token {
                trace!("Found string: {}", s);
                strings
                    .entry(s.clone())
                    .and_modify(|count| *count += 1)
                    .or_insert(1);
            }
        }

        let mut result: Vec<StringAnalysis> = strings
            .into_iter()
            .map(|(value, count)| {
                let is_path = self.path_regex.is_match(&value);
                let is_url = self.url_regex.is_match(&value);
                let is_email = self.email_regex.is_match(&value);

                StringAnalysis {
                    length: value.len(),
                    count,
                    is_path,
                    is_url,
                    is_email,
                    value,
                }
            })
            .collect();

        result.sort_by_key(|s| std::cmp::Reverse(s.count));
        debug!("Extracted {} unique strings", result.len());
        result
    }

    /// Filter strings by criteria
    pub fn filter_suspicious<'a>(&self, strings: &'a [StringAnalysis]) -> Vec<&'a StringAnalysis> {
        strings
            .iter()
            .filter(|s| {
                // Consider strings suspicious if they contain credentials patterns
                s.value.contains("password")
                    || s.value.contains("api_key")
                    || s.value.contains("token")
                    || s.value.contains("secret")
            })
            .collect()
    }

    /// Categorize strings
    pub fn categorize<'a>(
        &self,
        strings: &'a [StringAnalysis],
    ) -> (Vec<&'a StringAnalysis>, Vec<&'a StringAnalysis>, Vec<&'a StringAnalysis>) {
        let paths = strings.iter().filter(|s| s.is_path).collect();
        let urls = strings.iter().filter(|s| s.is_url).collect();
        let emails = strings.iter().filter(|s| s.is_email).collect();
        (paths, urls, emails)
    }
}

impl Default for StringExtractor {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_extract_strings() {
        let extractor = StringExtractor::new();
        let tokens = vec![
            Token::StringLiteral("hello".to_string()),
            Token::StringLiteral("world".to_string()),
            Token::StringLiteral("hello".to_string()),
        ];

        let strings = extractor.extract_from_tokens(&tokens);
        assert_eq!(strings.len(), 2);

        let hello = strings.iter().find(|s| s.value == "hello").unwrap();
        assert_eq!(hello.count, 2);
    }

    #[test]
    fn test_detect_paths() {
        let extractor = StringExtractor::new();
        let tokens = vec![
            Token::StringLiteral("/home/user/file.jsx".to_string()),
            Token::StringLiteral("C:\\Users\\file.jsx".to_string()),
        ];

        let strings = extractor.extract_from_tokens(&tokens);
        assert!(strings.iter().all(|s| s.is_path));
    }

    #[test]
    fn test_detect_urls() {
        let extractor = StringExtractor::new();
        let tokens = vec![
            Token::StringLiteral("https://example.com".to_string()),
            Token::StringLiteral("http://api.example.com".to_string()),
        ];

        let strings = extractor.extract_from_tokens(&tokens);
        assert!(strings.iter().all(|s| s.is_url));
    }

    #[test]
    fn test_filter_suspicious() {
        let extractor = StringExtractor::new();
        let strings = vec![
            StringAnalysis {
                value: "password123".to_string(),
                length: 11,
                count: 1,
                is_path: false,
                is_url: false,
                is_email: false,
            },
            StringAnalysis {
                value: "normal_string".to_string(),
                length: 12,
                count: 1,
                is_path: false,
                is_url: false,
                is_email: false,
            },
        ];

        let suspicious = extractor.filter_suspicious(&strings);
        assert_eq!(suspicious.len(), 1);
    }
}