jsxbin-analyzer 1.0.0

Comprehensive code analyzer for JSX with dependency detection, API classification, and security scanning
Documentation

analyzer

Crates.io Docs License

Comprehensive code analyzer for JSX with dependency detection, API classification, and security scanning.

Features

  • Dependency Detection: Extract #include, require(), and import statements
  • String Analysis: Categorize strings (paths, URLs, emails)
  • API Detection: Classify Adobe APIs (8+ categories)
  • Security Scanning: Detect vulnerabilities (eval, hardcoded credentials, SQL injection)
  • Function Graph: Build call dependency graph and detect cycles
  • Static Analysis: Code metrics and complexity scoring
  • No unsafe: 100% safe Rust

Quick Start

use analyzer::{DependencyDetector, SecurityScanner, ApiDetector};
use jsxbin_parser::Token;

let tokens = vec![
    Token::Identifier("activeDocument".to_string()),
    Token::StringLiteral("password=secret".to_string()),
];

// Detect APIs
let apis = ApiDetector::extract_from_tokens(&tokens);
println!("APIs: {:?}", apis);

// Scan security
let scanner = SecurityScanner::new();
let issues = scanner.scan_tokens(&tokens);
println!("Issues: {:?}", issues);

// Detect dependencies
let detector = DependencyDetector::new()?;
let deps = detector.extract_from_tokens(&tokens);
println!("Dependencies: {:?}", deps);

Analyzers

Dependency Detector

let detector = DependencyDetector::new()?;
let deps = detector.extract_from_code("#include \"utils.jsx\"")?;
// → Dependency { name: "utils.jsx", include_type: Include, ... }

String Extractor

let extractor = StringExtractor::new();
let strings = extractor.extract_from_tokens(&tokens);
// Categorizes as path/URL/email

API Detector

Classifies Adobe APIs:

  • Document: activeDocument, open, close, save
  • Layer: artLayers, layers, layerSets
  • Selection: selection, select, deselect
  • Transform: transform, scale, rotate
  • And 4 more categories

Security Scanner

let scanner = SecurityScanner::new();
let issues = scanner.scan_code("eval('code')")?;
// → SecurityIssue { eval_usage, severity: Critical, ... }

Detects:

  • ✅ eval() usage (CRITICAL)
  • ✅ Hardcoded credentials (HIGH)
  • ✅ SQL injection patterns (HIGH)
  • ✅ Dynamic code execution (CRITICAL)
  • ✅ File I/O access (MEDIUM)

Graph Builder

let mut builder = GraphBuilder::new();
let graph = builder.build_graph(&tokens);

// Detects cycles
let cycles = GraphBuilder::find_cycles(&graph);

// Calculate complexity
let complexity = GraphBuilder::calculate_complexity(&graph);

Performance

  • 1,000 tokens: ~12ms total analysis
    • Dependencies: 2ms
    • Strings: 1ms
    • APIs: 1ms
    • Security: 5ms
    • Graph: 3ms

Linear O(n) complexity per analyzer.

Examples

See examples/analyze_code.rs for complete working example.

cargo run --example analyze_code

Security Scoring

Base Score: 100

Deductions:
- Critical Issue: -30 points
- High Issue: -15 points
- Medium Issue: -5 points
- Low Issue: -1 point

Final Score: max(0, 100 - penalties)

Contributing

Contributions welcome! See CONTRIBUTING.md.

License

Licensed under the MIT License. See LICENSE file.

Related