Struct AnalyzerEngine 

pub struct AnalyzerEngine { /* private fields */ }

The main analysis engine

Combines native RMA rules with optional external providers (PMD, Oxlint) for comprehensive code analysis across multiple languages.

Implementations

impl AnalyzerEngine

pub fn new(config: RmaConfig) -> Self

Create a new analyzer with default rules (no external providers)

pub fn with_providers( config: RmaConfig, providers_config: ProvidersConfig, ) -> Self

Create a new analyzer with specified providers

pub fn is_provider_enabled(&self, provider_type: ProviderType) -> bool

Check if a provider is enabled

pub fn available_providers(&self) -> Vec<&str>

Get list of available providers

pub fn analyze_file(&self, parsed: &ParsedFile) -> Result<FileAnalysis>

Analyze a single parsed file using native rules only

pub fn analyze_files( &self, files: &[ParsedFile], ) -> Result<(Vec<FileAnalysis>, AnalysisSummary)>

Analyze multiple parsed files in parallel

This is the legacy method without caching support. For better performance on repeated scans, use analyze_files_cached instead.

pub fn analyze_files_cached( &self, files: &[ParsedFile], cache: Option<&mut AnalysisCache>, ) -> Result<(Vec<FileAnalysis>, AnalysisSummary)>

Analyze multiple parsed files in parallel with optional caching

When a cache is provided:

1. Files with unchanged content (based on hash) use cached results
2. Only modified/new files are analyzed
3. Fresh analysis results are stored in the cache
4. Combined results (cached + fresh) are returned

This can reduce scan time by 80-90% for repeated scans of the same codebase.

pub fn analyze_directory_with_providers( &self, path: &Path, ) -> Result<Vec<Finding>>

Run provider analysis on a directory

This is more efficient for providers that support batch analysis (like PMD which can analyze a whole directory at once).

pub fn analyze_files_with_providers( &self, files: &[ParsedFile], base_path: &Path, ) -> Result<(Vec<FileAnalysis>, AnalysisSummary)>

Analyze files with both native rules and providers

This combines:

1. Native rule analysis (per-file, parallel)
2. Provider analysis (batch where possible)