provenant/parsers/
hex_lock.rs

1use std::collections::HashMap;
2use std::fs;
3use std::path::Path;
4
5use log::warn;
6use packageurl::PackageUrl;
7use serde_json::Value as JsonValue;
8
9use crate::models::{DatasourceId, Dependency, PackageData, PackageType, ResolvedPackage};
10
11use super::PackageParser;
12
13pub struct HexLockParser;
14
15#[derive(Clone, Debug)]
16enum Term {
17    Map(Vec<(Term, Term)>),
18    Tuple(Vec<Term>),
19    List(Vec<Term>),
20    KeywordList(Vec<(String, Term)>),
21    String(String),
22    Atom(String),
23    Bool(bool),
24    Integer(i64),
25}
26
27struct Parser<'a> {
28    chars: Vec<char>,
29    pos: usize,
30    source: &'a str,
31}
32
33impl PackageParser for HexLockParser {
34    const PACKAGE_TYPE: PackageType = PackageType::Hex;
35
36    fn is_match(path: &Path) -> bool {
37        path.file_name().and_then(|name| name.to_str()) == Some("mix.lock")
38    }
39
40    fn extract_packages(path: &Path) -> Vec<PackageData> {
41        let content = match fs::read_to_string(path) {
42            Ok(content) => content,
43            Err(e) => {
44                warn!("Failed to read mix.lock at {:?}: {}", path, e);
45                return vec![default_package_data()];
46            }
47        };
48
49        match parse_mix_lock(&content) {
50            Ok(package_data) => vec![package_data],
51            Err(e) => {
52                warn!("Failed to parse mix.lock at {:?}: {}", path, e);
53                vec![default_package_data()]
54            }
55        }
56    }
57}
58
59fn default_package_data() -> PackageData {
60    PackageData {
61        package_type: Some(PackageType::Hex),
62        primary_language: Some("Elixir".to_string()),
63        datasource_id: Some(DatasourceId::HexMixLock),
64        ..Default::default()
65    }
66}
67
68fn parse_mix_lock(content: &str) -> Result<PackageData, String> {
69    let mut parser = Parser::new(content);
70    let term = parser.parse_term()?;
71    parser.skip_ws();
72    if !parser.is_eof() {
73        return Err("Unexpected trailing content in mix.lock".to_string());
74    }
75
76    let entries = match term {
77        Term::Map(entries) => entries,
78        _ => return Err("mix.lock root must be a map".to_string()),
79    };
80
81    let mut dependencies = Vec::new();
82    for (key, value) in entries {
83        if let Some(dep) = build_dependency_from_lock_entry(&key, &value)? {
84            dependencies.push(dep);
85        }
86    }
87
88    let mut package = default_package_data();
89    package.dependencies = dependencies;
90    Ok(package)
91}
92
93fn build_dependency_from_lock_entry(
94    key: &Term,
95    value: &Term,
96) -> Result<Option<Dependency>, String> {
97    let app_name = term_to_string(key)?;
98
99    let tuple = match value {
100        Term::Tuple(items) => items,
101        _ => return Ok(None),
102    };
103
104    if tuple.len() < 8 {
105        return Ok(None);
106    }
107
108    let kind = term_to_atom(&tuple[0])?;
109    if kind != "hex" {
110        return Ok(None);
111    }
112
113    let package_name = term_to_atom(&tuple[1])?;
114    let version = term_to_string(&tuple[2])?;
115    let inner_checksum = term_to_string(&tuple[3])?;
116    let managers = term_to_atom_list(&tuple[4])?;
117    let nested_dependencies = term_to_dependency_tuples(&tuple[5])?;
118    let repo = term_to_string(&tuple[6])?;
119    let outer_checksum = term_to_string(&tuple[7])?;
120
121    let purl = build_hex_purl(&package_name, Some(&version), Some(&repo));
122    let resolved_package = ResolvedPackage {
123        package_type: PackageType::Hex,
124        namespace: if repo == "hexpm" {
125            String::new()
126        } else {
127            repo.clone()
128        },
129        name: package_name.clone(),
130        version: version.clone(),
131        primary_language: Some("Elixir".to_string()),
132        download_url: None,
133        sha1: None,
134        sha256: Some(inner_checksum),
135        sha512: None,
136        md5: None,
137        is_virtual: true,
138        extra_data: Some(HashMap::from([
139            ("repo".to_string(), JsonValue::String(repo.clone())),
140            (
141                "outer_checksum".to_string(),
142                JsonValue::String(outer_checksum.clone()),
143            ),
144            (
145                "managers".to_string(),
146                JsonValue::Array(managers.into_iter().map(JsonValue::String).collect()),
147            ),
148        ])),
149        dependencies: nested_dependencies
150            .into_iter()
151            .map(build_nested_dependency)
152            .collect::<Result<Vec<_>, _>>()?,
153        repository_homepage_url: Some(build_hexdocs_homepage(&package_name, &repo)),
154        repository_download_url: None,
155        api_data_url: Some(build_hex_api_url(&package_name, &repo)),
156        datasource_id: Some(DatasourceId::HexMixLock),
157        purl: build_hex_purl(&package_name, Some(&version), Some(&repo)),
158    };
159
160    Ok(Some(Dependency {
161        purl,
162        extracted_requirement: Some(version),
163        scope: Some("dependencies".to_string()),
164        is_runtime: Some(true),
165        is_optional: Some(false),
166        is_pinned: Some(true),
167        is_direct: Some(false),
168        resolved_package: Some(Box::new(resolved_package)),
169        extra_data: Some(HashMap::from([(
170            "app".to_string(),
171            JsonValue::String(app_name),
172        )])),
173    }))
174}
175
176fn build_nested_dependency(tuple: DependencyTuple) -> Result<Dependency, String> {
177    let package_name = tuple
178        .hex_name
179        .clone()
180        .unwrap_or_else(|| tuple.app_name.clone());
181    Ok(Dependency {
182        purl: build_hex_purl(&package_name, None, tuple.repo.as_deref()),
183        extracted_requirement: Some(tuple.requirement),
184        scope: Some("dependencies".to_string()),
185        is_runtime: Some(!tuple.optional),
186        is_optional: Some(tuple.optional),
187        is_pinned: Some(false),
188        is_direct: Some(true),
189        resolved_package: None,
190        extra_data: None,
191    })
192}
193
194#[derive(Debug)]
195struct DependencyTuple {
196    app_name: String,
197    requirement: String,
198    hex_name: Option<String>,
199    repo: Option<String>,
200    optional: bool,
201}
202
203fn term_to_dependency_tuples(term: &Term) -> Result<Vec<DependencyTuple>, String> {
204    let items = match term {
205        Term::List(items) => items,
206        _ => return Ok(Vec::new()),
207    };
208
209    let mut result = Vec::new();
210    for item in items {
211        let tuple = match item {
212            Term::Tuple(items) if items.len() == 3 => items,
213            _ => continue,
214        };
215
216        let app_name = term_to_atom(&tuple[0])?;
217        let requirement = term_to_string(&tuple[1])?;
218        let opts = term_to_keyword_map(&tuple[2])?;
219        let hex_name = opts.get("hex").map(term_to_atom).transpose()?;
220        let repo = opts.get("repo").map(term_to_string).transpose()?;
221        let optional = opts
222            .get("optional")
223            .and_then(|term| match term {
224                Term::Bool(value) => Some(*value),
225                _ => None,
226            })
227            .unwrap_or(false);
228
229        result.push(DependencyTuple {
230            app_name,
231            requirement,
232            hex_name,
233            repo,
234            optional,
235        });
236    }
237
238    Ok(result)
239}
240
241fn term_to_keyword_map(term: &Term) -> Result<HashMap<String, Term>, String> {
242    match term {
243        Term::KeywordList(entries) => Ok(entries.iter().cloned().collect()),
244        Term::List(entries) => {
245            let mut map = HashMap::new();
246            for entry in entries {
247                if let Term::Tuple(items) = entry
248                    && items.len() == 2
249                {
250                    map.insert(term_to_atom(&items[0])?, items[1].clone());
251                }
252            }
253            Ok(map)
254        }
255        _ => Ok(HashMap::new()),
256    }
257}
258
259fn build_hex_purl(name: &str, version: Option<&str>, repo: Option<&str>) -> Option<String> {
260    let mut purl = PackageUrl::new("hex", name).ok()?;
261    if let Some(repo) = repo
262        && repo != "hexpm"
263    {
264        purl.with_namespace(repo).ok()?;
265    }
266    if let Some(version) = version {
267        purl.with_version(version).ok()?;
268    }
269    Some(purl.to_string())
270}
271
272fn build_hexdocs_homepage(name: &str, repo: &str) -> String {
273    if repo == "hexpm" {
274        format!("https://hex.pm/packages/{}", name)
275    } else {
276        format!("https://hex.pm/packages/{}?repo={}", name, repo)
277    }
278}
279
280fn build_hex_api_url(name: &str, repo: &str) -> String {
281    if repo == "hexpm" {
282        format!("https://hex.pm/api/packages/{}", name)
283    } else {
284        format!("https://hex.pm/api/repos/{}/packages/{}", repo, name)
285    }
286}
287
288fn term_to_string(term: &Term) -> Result<String, String> {
289    match term {
290        Term::String(value) => Ok(value.clone()),
291        Term::Atom(value) => Ok(value.clone()),
292        Term::Integer(value) => Ok(value.to_string()),
293        _ => Err("Expected string-like term".to_string()),
294    }
295}
296
297fn term_to_atom(term: &Term) -> Result<String, String> {
298    match term {
299        Term::Atom(value) => Ok(value.clone()),
300        _ => Err("Expected atom".to_string()),
301    }
302}
303
304fn term_to_atom_list(term: &Term) -> Result<Vec<String>, String> {
305    let items = match term {
306        Term::List(items) => items,
307        _ => return Ok(Vec::new()),
308    };
309    items.iter().map(term_to_atom).collect()
310}
311
312impl<'a> Parser<'a> {
313    fn new(source: &'a str) -> Self {
314        Self {
315            chars: source.chars().collect(),
316            pos: 0,
317            source,
318        }
319    }
320
321    fn parse_term(&mut self) -> Result<Term, String> {
322        self.skip_ws();
323        match self.peek() {
324            Some('%') => self.parse_map(),
325            Some('{') => self.parse_tuple(),
326            Some('[') => self.parse_list(),
327            Some('"') => self.parse_string().map(Term::String),
328            Some(':') => self.parse_atom().map(Term::Atom),
329            Some(c) if c.is_ascii_digit() || c == '-' => self.parse_integer().map(Term::Integer),
330            Some('t') | Some('f') => self.parse_bool().map(Term::Bool),
331            Some(other) => Err(format!("Unexpected character '{}' at {}", other, self.pos)),
332            None => Err("Unexpected end of mix.lock".to_string()),
333        }
334    }
335
336    fn parse_map(&mut self) -> Result<Term, String> {
337        self.expect('%')?;
338        self.expect('{')?;
339        let mut entries = Vec::new();
340        loop {
341            self.skip_ws();
342            if self.peek() == Some('}') {
343                self.pos += 1;
344                break;
345            }
346            let key = self.parse_term()?;
347            self.skip_ws();
348            if self.starts_with("=>") {
349                self.expect_sequence("=>")?;
350            } else {
351                self.expect(':')?;
352            }
353            let value = self.parse_term()?;
354            entries.push((key, value));
355            self.skip_ws();
356            if self.peek() == Some(',') {
357                self.pos += 1;
358            }
359        }
360        Ok(Term::Map(entries))
361    }
362
363    fn parse_tuple(&mut self) -> Result<Term, String> {
364        self.expect('{')?;
365        let mut items = Vec::new();
366        loop {
367            self.skip_ws();
368            if self.peek() == Some('}') {
369                self.pos += 1;
370                break;
371            }
372            items.push(self.parse_term()?);
373            self.skip_ws();
374            if self.peek() == Some(',') {
375                self.pos += 1;
376            }
377        }
378        Ok(Term::Tuple(items))
379    }
380
381    fn parse_list(&mut self) -> Result<Term, String> {
382        self.expect('[')?;
383        let mut keyword_entries = Vec::new();
384        let mut items = Vec::new();
385        let mut saw_keyword = false;
386
387        loop {
388            self.skip_ws();
389            if self.peek() == Some(']') {
390                self.pos += 1;
391                break;
392            }
393
394            if let Some(keyword) = self.try_parse_keyword_key() {
395                saw_keyword = true;
396                let value = self.parse_term()?;
397                keyword_entries.push((keyword, value));
398            } else {
399                items.push(self.parse_term()?);
400            }
401
402            self.skip_ws();
403            if self.peek() == Some(',') {
404                self.pos += 1;
405            }
406        }
407
408        if saw_keyword && items.is_empty() {
409            Ok(Term::KeywordList(keyword_entries))
410        } else if saw_keyword {
411            let mut merged = items;
412            merged.extend(
413                keyword_entries
414                    .into_iter()
415                    .map(|(k, v)| Term::Tuple(vec![Term::Atom(k), v])),
416            );
417            Ok(Term::List(merged))
418        } else {
419            Ok(Term::List(items))
420        }
421    }
422
423    fn try_parse_keyword_key(&mut self) -> Option<String> {
424        let saved = self.pos;
425        self.skip_ws();
426        let start = self.pos;
427        while let Some(c) = self.peek() {
428            if c.is_ascii_alphanumeric() || c == '_' || c == '?' || c == '!' {
429                self.pos += 1;
430            } else {
431                break;
432            }
433        }
434        if self.pos == start || self.peek() != Some(':') || self.peek_n(1) == Some(':') {
435            self.pos = saved;
436            return None;
437        }
438        let key: String = self.chars[start..self.pos].iter().collect();
439        self.pos += 1;
440        Some(key)
441    }
442
443    fn parse_string(&mut self) -> Result<String, String> {
444        self.expect('"')?;
445        let mut out = String::new();
446        while let Some(c) = self.peek() {
447            self.pos += 1;
448            match c {
449                '"' => return Ok(out),
450                '\\' => {
451                    let escaped = self
452                        .peek()
453                        .ok_or_else(|| "Unterminated string escape".to_string())?;
454                    self.pos += 1;
455                    out.push(match escaped {
456                        'n' => '\n',
457                        'r' => '\r',
458                        't' => '\t',
459                        '"' => '"',
460                        '\\' => '\\',
461                        other => other,
462                    });
463                }
464                other => out.push(other),
465            }
466        }
467        Err("Unterminated string literal".to_string())
468    }
469
470    fn parse_atom(&mut self) -> Result<String, String> {
471        self.expect(':')?;
472        let start = self.pos;
473        while let Some(c) = self.peek() {
474            if c.is_ascii_alphanumeric() || c == '_' || c == '?' || c == '!' || c == '@' {
475                self.pos += 1;
476            } else {
477                break;
478            }
479        }
480        if self.pos == start {
481            return Err("Expected atom after ':'".to_string());
482        }
483        Ok(self.chars[start..self.pos].iter().collect())
484    }
485
486    fn parse_integer(&mut self) -> Result<i64, String> {
487        let start = self.pos;
488        if self.peek() == Some('-') {
489            self.pos += 1;
490        }
491        while let Some(c) = self.peek() {
492            if c.is_ascii_digit() {
493                self.pos += 1;
494            } else {
495                break;
496            }
497        }
498        self.source[start..self.byte_index(self.pos)]
499            .parse::<i64>()
500            .map_err(|e| format!("Invalid integer: {}", e))
501    }
502
503    fn parse_bool(&mut self) -> Result<bool, String> {
504        if self.starts_with("true") {
505            self.pos += 4;
506            Ok(true)
507        } else if self.starts_with("false") {
508            self.pos += 5;
509            Ok(false)
510        } else {
511            Err("Invalid boolean".to_string())
512        }
513    }
514
515    fn skip_ws(&mut self) {
516        while let Some(c) = self.peek() {
517            if c.is_whitespace() {
518                self.pos += 1;
519            } else {
520                break;
521            }
522        }
523    }
524
525    fn expect(&mut self, expected: char) -> Result<(), String> {
526        match self.peek() {
527            Some(c) if c == expected => {
528                self.pos += 1;
529                Ok(())
530            }
531            Some(c) => Err(format!("Expected '{}' but found '{}'", expected, c)),
532            None => Err(format!("Expected '{}' but reached end of input", expected)),
533        }
534    }
535
536    fn expect_sequence(&mut self, expected: &str) -> Result<(), String> {
537        if self.starts_with(expected) {
538            self.pos += expected.chars().count();
539            Ok(())
540        } else {
541            Err(format!("Expected '{}' at {}", expected, self.pos))
542        }
543    }
544
545    fn starts_with(&self, s: &str) -> bool {
546        self.chars[self.pos..]
547            .iter()
548            .collect::<String>()
549            .starts_with(s)
550    }
551
552    fn peek(&self) -> Option<char> {
553        self.chars.get(self.pos).copied()
554    }
555
556    fn peek_n(&self, n: usize) -> Option<char> {
557        self.chars.get(self.pos + n).copied()
558    }
559
560    fn is_eof(&self) -> bool {
561        self.pos >= self.chars.len()
562    }
563
564    fn byte_index(&self, char_pos: usize) -> usize {
565        self.chars.iter().take(char_pos).map(|c| c.len_utf8()).sum()
566    }
567}
provenant/parsers/hex_lock.rs

provenant/parsers/
hex_lock.rs
