jsxbin-analyzer 1.0.0

Comprehensive code analyzer for JSX with dependency detection, API classification, and security scanning
Documentation
use jsxbin_analyzer::{ApiDetector, DependencyDetector, SecurityScanner, StringExtractor};
use jsxbin_parser::Token;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Code Analyzer Examples ===\n");

    // Example 1: Dependency detection
    println!("Example 1: Dependency Detection");
    let detector = DependencyDetector::new()?;
    let code = r#"#include "utils.jsx"
require("lodash")
import React from "react""#;

    let deps = detector.extract_from_code(code)?;
    println!("  Dependencies found: {}", deps.len());
    for dep in deps {
        println!("    - {} ({:?})", dep.name, dep.include_type);
    }

    // Example 2: String extraction
    println!("\nExample 2: String Extraction");
    let extractor = StringExtractor::new();
    let tokens = vec![
        Token::StringLiteral("/home/user/file.jsx".to_string()),
        Token::StringLiteral("https://example.com".to_string()),
        Token::StringLiteral("user@example.com".to_string()),
        Token::StringLiteral("hello".to_string()),
    ];

    let strings = extractor.extract_from_tokens(&tokens);
    println!("  Strings found: {}", strings.len());
    for s in strings {
        let types = vec![
            if s.is_path { "path" } else { "" },
            if s.is_url { "url" } else { "" },
            if s.is_email { "email" } else { "" },
        ]
        .into_iter()
        .filter(|s| !s.is_empty())
        .collect::<Vec<_>>()
        .join(", ");

        println!("    - \"{}\" [{}]", s.value, types);
    }

    // Example 3: API detection
    println!("\nExample 3: API Detection");
    let tokens = vec![
        Token::Identifier("activeDocument".to_string()),
        Token::Identifier("selection".to_string()),
        Token::Identifier("transform".to_string()),
    ];

    let apis = ApiDetector::extract_from_tokens(&tokens);
    println!("  APIs found: {}", apis.len());
    for api in apis {
        println!("    - {} ({:?})", api.api_name, api.api_type);
    }

    // Example 4: Security scanning
    println!("\nExample 4: Security Scanning");
    let scanner = SecurityScanner::new();

    let test_cases = vec![
        ("eval('code')", "eval() usage"),
        (r#"password = "secret123""#, "hardcoded credential"),
        ("\"SELECT * FROM users WHERE id = \" + userId", "SQL injection"),
        ("normal code", "clean code"),
    ];

    for (code, desc) in test_cases {
        let issues = scanner.scan_code(code);
        if issues.is_empty() {
            println!("  [✓] {} - No issues", desc);
        } else {
            println!("  [⚠] {} - {} issue(s)", desc, issues.len());
            for issue in issues {
                println!("      - {:?}: {:?}", issue.issue_type, issue.severity);
            }
        }
    }

    // Example 5: Security score
    println!("\nExample 5: Security Scoring");
    let clean_tokens = vec![
        Token::StringLiteral("hello".to_string()),
        Token::NumberLiteral(42.0),
    ];

    let unsafe_tokens = vec![Token::Identifier("eval".to_string())];

    let clean_score = scanner.calculate_security_score(&clean_tokens);
    let unsafe_score = scanner.calculate_security_score(&unsafe_tokens);

    println!("  Clean code: {}/100", clean_score);
    println!("  Unsafe code: {}/100", unsafe_score);

    println!("\n✅ All examples completed successfully!");

    Ok(())
}