use crate::error::{AnalysisError, AnalysisResult};
use crate::types::{Dependency, IncludeType};
use jsxbin_parser::types::Token;
use log::{debug, trace};
use regex::Regex;
pub struct DependencyDetector {
include_regex: Regex,
require_regex: Regex,
import_regex: Regex,
}
impl DependencyDetector {
pub fn new() -> AnalysisResult<Self> {
Ok(DependencyDetector {
include_regex: Regex::new(r#"#include\s+[<"]([^>"]+)[>"]"#)
.map_err(|e| AnalysisError::PatternError(e.to_string()))?,
require_regex: Regex::new(r#"require\s*\(\s*['"]([^'"]+)['"]\s*\)"#)
.map_err(|e| AnalysisError::PatternError(e.to_string()))?,
import_regex: Regex::new(r#"import\s+.*\s+from\s+['"]([^'"]+)['"]\s*;"#)
.map_err(|e| AnalysisError::PatternError(e.to_string()))?,
})
}
pub fn extract_from_tokens(&self, tokens: &[Token]) -> Vec<Dependency> {
debug!("Extracting dependencies from {} tokens", tokens.len());
let mut deps = Vec::new();
for token in tokens {
if let Token::StringLiteral(s) = token {
if s.contains('/') || s.ends_with(".jsx") || s.ends_with(".js") {
if !deps.iter().any(|d: &Dependency| d.name == *s) {
deps.push(Dependency {
name: s.clone(),
include_type: IncludeType::Include,
line: None,
count: 1,
});
} else {
if let Some(dep) = deps.iter_mut().find(|d| d.name == *s) {
dep.count += 1;
}
}
}
}
}
debug!("Found {} dependencies", deps.len());
deps
}
pub fn extract_from_code(&self, code: &str) -> AnalysisResult<Vec<Dependency>> {
debug!("Extracting dependencies from code string");
let mut deps = Vec::new();
for cap in self.include_regex.captures_iter(code) {
if let Some(path) = cap.get(1) {
let name = path.as_str().to_string();
trace!("Found include: {}", name);
deps.push(Dependency {
name,
include_type: IncludeType::Include,
line: None,
count: 1,
});
}
}
for cap in self.require_regex.captures_iter(code) {
if let Some(module) = cap.get(1) {
let name = module.as_str().to_string();
trace!("Found require: {}", name);
if let Some(dep) = deps.iter_mut().find(|d| d.name == name) {
dep.count += 1;
} else {
deps.push(Dependency {
name,
include_type: IncludeType::Require,
line: None,
count: 1,
});
}
}
}
for cap in self.import_regex.captures_iter(code) {
if let Some(module) = cap.get(1) {
let name = module.as_str().to_string();
trace!("Found import: {}", name);
if let Some(dep) = deps.iter_mut().find(|d| d.name == name) {
dep.count += 1;
} else {
deps.push(Dependency {
name,
include_type: IncludeType::Import,
line: None,
count: 1,
});
}
}
}
debug!("Found {} dependencies total", deps.len());
Ok(deps)
}
pub fn deduplicate(deps: &[Dependency]) -> Vec<Dependency> {
let mut deduped: Vec<Dependency> = Vec::new();
for dep in deps {
if let Some(existing) = deduped.iter_mut().find(|d| d.name == dep.name) {
existing.count += dep.count;
} else {
deduped.push(dep.clone());
}
}
deduped
}
}
impl Default for DependencyDetector {
fn default() -> Self {
Self::new().unwrap()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_extract_include() {
let detector = DependencyDetector::new().unwrap();
let code = r#"#include "utils.jsx""#;
let deps = detector.extract_from_code(code).unwrap();
assert_eq!(deps.len(), 1);
assert_eq!(deps[0].name, "utils.jsx");
assert_eq!(deps[0].include_type, IncludeType::Include);
}
#[test]
fn test_extract_require() {
let detector = DependencyDetector::new().unwrap();
let code = r#"require("lodash")"#;
let deps = detector.extract_from_code(code).unwrap();
assert_eq!(deps.len(), 1);
assert_eq!(deps[0].name, "lodash");
assert_eq!(deps[0].include_type, IncludeType::Require);
}
#[test]
fn test_deduplicate() {
let deps = vec![
Dependency {
name: "utils.jsx".to_string(),
include_type: IncludeType::Include,
line: None,
count: 1,
},
Dependency {
name: "utils.jsx".to_string(),
include_type: IncludeType::Include,
line: None,
count: 1,
},
];
let deduped = DependencyDetector::deduplicate(&deps);
assert_eq!(deduped.len(), 1);
assert_eq!(deduped[0].count, 2);
}
}