Skip to main content

jsxbin_analyzer/
types.rs

1use serde::{Deserialize, Serialize};
2use std::collections::{HashMap, HashSet};
3
4/// Results of code analysis
5#[derive(Debug, Clone, Serialize, Deserialize)]
6pub struct AnalysisReport {
7    pub dependencies: Vec<Dependency>,
8    pub strings: Vec<StringAnalysis>,
9    pub apis: Vec<ApiUsage>,
10    pub security_issues: Vec<SecurityIssue>,
11    pub function_graph: FunctionGraph,
12    pub statistics: Statistics,
13}
14
15/// Represents a code dependency
16#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
17pub struct Dependency {
18    pub name: String,
19    pub include_type: IncludeType,
20    pub line: Option<usize>,
21    pub count: usize,
22}
23
24#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
25pub enum IncludeType {
26    Include,
27    Require,
28    Import,
29    Other,
30}
31
32/// String literal analysis
33#[derive(Debug, Clone, Serialize, Deserialize)]
34pub struct StringAnalysis {
35    pub value: String,
36    pub length: usize,
37    pub count: usize,
38    pub is_path: bool,
39    pub is_url: bool,
40    pub is_email: bool,
41}
42
43/// Adobe API usage
44#[derive(Debug, Clone, Serialize, Deserialize)]
45pub struct ApiUsage {
46    pub api_name: String,
47    pub api_type: ApiType,
48    pub count: usize,
49    pub locations: Vec<usize>,
50}
51
52#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
53pub enum ApiType {
54    Document,
55    Layer,
56    Selection,
57    Transform,
58    Effects,
59    Text,
60    Shape,
61    Color,
62    Other,
63}
64
65/// Security concern found in code
66#[derive(Debug, Clone, Serialize, Deserialize)]
67pub struct SecurityIssue {
68    pub issue_type: SecurityIssueType,
69    pub description: String,
70    pub severity: Severity,
71    pub location: Option<String>,
72}
73
74#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
75pub enum SecurityIssueType {
76    EvalUsage,
77    HardcodedCredentials,
78    CommandInjection,
79    FileAccess,
80    NetworkAccess,
81    DynamicCode,
82    Other,
83}
84
85#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
86pub enum Severity {
87    Low,
88    Medium,
89    High,
90    Critical,
91}
92
93/// Function call graph
94#[derive(Debug, Clone, Serialize, Deserialize)]
95pub struct FunctionGraph {
96    pub nodes: Vec<FunctionNode>,
97    pub edges: Vec<FunctionEdge>,
98}
99
100#[derive(Debug, Clone, Serialize, Deserialize)]
101pub struct FunctionNode {
102    pub id: usize,
103    pub name: String,
104    pub params: usize,
105    pub calls_count: usize,
106    pub is_exported: bool,
107}
108
109#[derive(Debug, Clone, Serialize, Deserialize)]
110pub struct FunctionEdge {
111    pub from: usize,
112    pub to: usize,
113    pub count: usize,
114}
115
116/// Statistical summary
117#[derive(Debug, Clone, Serialize, Deserialize, Default)]
118pub struct Statistics {
119    pub total_functions: usize,
120    pub total_variables: usize,
121    pub total_strings: usize,
122    pub total_numbers: usize,
123    pub average_function_size: f64,
124    pub complexity_score: f64,
125    pub security_score: f64,
126}
127
128impl AnalysisReport {
129    /// Create an empty report
130    pub fn new() -> Self {
131        AnalysisReport {
132            dependencies: Vec::new(),
133            strings: Vec::new(),
134            apis: Vec::new(),
135            security_issues: Vec::new(),
136            function_graph: FunctionGraph {
137                nodes: Vec::new(),
138                edges: Vec::new(),
139            },
140            statistics: Statistics::default(),
141        }
142    }
143
144    /// Get critical security issues
145    pub fn critical_issues(&self) -> Vec<&SecurityIssue> {
146        self.security_issues
147            .iter()
148            .filter(|i| i.severity == Severity::Critical)
149            .collect()
150    }
151
152    /// Get all unique API types used
153    pub fn used_api_types(&self) -> HashSet<ApiType> {
154        self.apis.iter().map(|a| a.api_type).collect()
155    }
156}