jsxbin-analyzer 1.0.0

Comprehensive code analyzer for JSX with dependency detection, API classification, and security scanning
Documentation
use crate::error::{AnalysisError, AnalysisResult};
use crate::types::{Dependency, IncludeType};
use jsxbin_parser::types::Token;
use log::{debug, trace};
use regex::Regex;

/// Detects and extracts dependencies from code
pub struct DependencyDetector {
    include_regex: Regex,
    require_regex: Regex,
    import_regex: Regex,
}

impl DependencyDetector {
    /// Create a new dependency detector
    pub fn new() -> AnalysisResult<Self> {
        Ok(DependencyDetector {
            // Matches: #include "file.jsx" or #include <file>
            include_regex: Regex::new(r#"#include\s+[<"]([^>"]+)[>"]"#)
                .map_err(|e| AnalysisError::PatternError(e.to_string()))?,

            // Matches: require("module") or require('module')
            require_regex: Regex::new(r#"require\s*\(\s*['"]([^'"]+)['"]\s*\)"#)
                .map_err(|e| AnalysisError::PatternError(e.to_string()))?,

            // Matches: import ... from "module" or import ... from 'module'
            import_regex: Regex::new(r#"import\s+.*\s+from\s+['"]([^'"]+)['"]\s*;"#)
                .map_err(|e| AnalysisError::PatternError(e.to_string()))?,
        })
    }

    /// Extract dependencies from tokens
    pub fn extract_from_tokens(&self, tokens: &[Token]) -> Vec<Dependency> {
        debug!("Extracting dependencies from {} tokens", tokens.len());
        let mut deps = Vec::new();

        for token in tokens {
            if let Token::StringLiteral(s) = token {
                // Check if string looks like a file path or module name
                if s.contains('/') || s.ends_with(".jsx") || s.ends_with(".js") {
                    if !deps.iter().any(|d: &Dependency| d.name == *s) {
                        deps.push(Dependency {
                            name: s.clone(),
                            include_type: IncludeType::Include,
                            line: None,
                            count: 1,
                        });
                    } else {
                        if let Some(dep) = deps.iter_mut().find(|d| d.name == *s) {
                            dep.count += 1;
                        }
                    }
                }
            }
        }

        debug!("Found {} dependencies", deps.len());
        deps
    }

    /// Extract dependencies from code string
    pub fn extract_from_code(&self, code: &str) -> AnalysisResult<Vec<Dependency>> {
        debug!("Extracting dependencies from code string");
        let mut deps = Vec::new();

        // Find includes
        for cap in self.include_regex.captures_iter(code) {
            if let Some(path) = cap.get(1) {
                let name = path.as_str().to_string();
                trace!("Found include: {}", name);
                deps.push(Dependency {
                    name,
                    include_type: IncludeType::Include,
                    line: None,
                    count: 1,
                });
            }
        }

        // Find requires
        for cap in self.require_regex.captures_iter(code) {
            if let Some(module) = cap.get(1) {
                let name = module.as_str().to_string();
                trace!("Found require: {}", name);
                if let Some(dep) = deps.iter_mut().find(|d| d.name == name) {
                    dep.count += 1;
                } else {
                    deps.push(Dependency {
                        name,
                        include_type: IncludeType::Require,
                        line: None,
                        count: 1,
                    });
                }
            }
        }

        // Find imports
        for cap in self.import_regex.captures_iter(code) {
            if let Some(module) = cap.get(1) {
                let name = module.as_str().to_string();
                trace!("Found import: {}", name);
                if let Some(dep) = deps.iter_mut().find(|d| d.name == name) {
                    dep.count += 1;
                } else {
                    deps.push(Dependency {
                        name,
                        include_type: IncludeType::Import,
                        line: None,
                        count: 1,
                    });
                }
            }
        }

        debug!("Found {} dependencies total", deps.len());
        Ok(deps)
    }

    /// Merge duplicate dependencies
    pub fn deduplicate(deps: &[Dependency]) -> Vec<Dependency> {
        let mut deduped: Vec<Dependency> = Vec::new();
        for dep in deps {
            if let Some(existing) = deduped.iter_mut().find(|d| d.name == dep.name) {
                existing.count += dep.count;
            } else {
                deduped.push(dep.clone());
            }
        }
        deduped
    }
}

impl Default for DependencyDetector {
    fn default() -> Self {
        Self::new().unwrap()
    }
}

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

    #[test]
    fn test_extract_include() {
        let detector = DependencyDetector::new().unwrap();
        let code = r#"#include "utils.jsx""#;
        let deps = detector.extract_from_code(code).unwrap();
        assert_eq!(deps.len(), 1);
        assert_eq!(deps[0].name, "utils.jsx");
        assert_eq!(deps[0].include_type, IncludeType::Include);
    }

    #[test]
    fn test_extract_require() {
        let detector = DependencyDetector::new().unwrap();
        let code = r#"require("lodash")"#;
        let deps = detector.extract_from_code(code).unwrap();
        assert_eq!(deps.len(), 1);
        assert_eq!(deps[0].name, "lodash");
        assert_eq!(deps[0].include_type, IncludeType::Require);
    }

    #[test]
    fn test_deduplicate() {
        let deps = vec![
            Dependency {
                name: "utils.jsx".to_string(),
                include_type: IncludeType::Include,
                line: None,
                count: 1,
            },
            Dependency {
                name: "utils.jsx".to_string(),
                include_type: IncludeType::Include,
                line: None,
                count: 1,
            },
        ];
        let deduped = DependencyDetector::deduplicate(&deps);
        assert_eq!(deduped.len(), 1);
        assert_eq!(deduped[0].count, 2);
    }
}