jsxbin-analyzer 1.0.0

Comprehensive code analyzer for JSX with dependency detection, API classification, and security scanning
Documentation
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};

/// Results of code analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalysisReport {
    pub dependencies: Vec<Dependency>,
    pub strings: Vec<StringAnalysis>,
    pub apis: Vec<ApiUsage>,
    pub security_issues: Vec<SecurityIssue>,
    pub function_graph: FunctionGraph,
    pub statistics: Statistics,
}

/// Represents a code dependency
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub struct Dependency {
    pub name: String,
    pub include_type: IncludeType,
    pub line: Option<usize>,
    pub count: usize,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum IncludeType {
    Include,
    Require,
    Import,
    Other,
}

/// String literal analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StringAnalysis {
    pub value: String,
    pub length: usize,
    pub count: usize,
    pub is_path: bool,
    pub is_url: bool,
    pub is_email: bool,
}

/// Adobe API usage
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiUsage {
    pub api_name: String,
    pub api_type: ApiType,
    pub count: usize,
    pub locations: Vec<usize>,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum ApiType {
    Document,
    Layer,
    Selection,
    Transform,
    Effects,
    Text,
    Shape,
    Color,
    Other,
}

/// Security concern found in code
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SecurityIssue {
    pub issue_type: SecurityIssueType,
    pub description: String,
    pub severity: Severity,
    pub location: Option<String>,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum SecurityIssueType {
    EvalUsage,
    HardcodedCredentials,
    CommandInjection,
    FileAccess,
    NetworkAccess,
    DynamicCode,
    Other,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
pub enum Severity {
    Low,
    Medium,
    High,
    Critical,
}

/// Function call graph
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FunctionGraph {
    pub nodes: Vec<FunctionNode>,
    pub edges: Vec<FunctionEdge>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FunctionNode {
    pub id: usize,
    pub name: String,
    pub params: usize,
    pub calls_count: usize,
    pub is_exported: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FunctionEdge {
    pub from: usize,
    pub to: usize,
    pub count: usize,
}

/// Statistical summary
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct Statistics {
    pub total_functions: usize,
    pub total_variables: usize,
    pub total_strings: usize,
    pub total_numbers: usize,
    pub average_function_size: f64,
    pub complexity_score: f64,
    pub security_score: f64,
}

impl AnalysisReport {
    /// Create an empty report
    pub fn new() -> Self {
        AnalysisReport {
            dependencies: Vec::new(),
            strings: Vec::new(),
            apis: Vec::new(),
            security_issues: Vec::new(),
            function_graph: FunctionGraph {
                nodes: Vec::new(),
                edges: Vec::new(),
            },
            statistics: Statistics::default(),
        }
    }

    /// Get critical security issues
    pub fn critical_issues(&self) -> Vec<&SecurityIssue> {
        self.security_issues
            .iter()
            .filter(|i| i.severity == Severity::Critical)
            .collect()
    }

    /// Get all unique API types used
    pub fn used_api_types(&self) -> HashSet<ApiType> {
        self.apis.iter().map(|a| a.api_type).collect()
    }
}