Skip to main content

lockdocs_core/extract/
package.rs

1//! Run extraction jobs and reconcile entries for the package index.
2
3use super::docs::{example, page_markdown, page_title, prose, prose_titled, Includes};
4use super::go::go_file;
5use super::plan::{plan, How, MAX_FILE_BYTES};
6use super::python::py_file;
7use super::rust::{rs_file, rust_crate_name};
8use super::typescript::ts_file;
9use super::Entry;
10use crate::locate::Source;
11use crate::markdown;
12use crate::Eco;
13use rayon::prelude::*;
14use std::collections::HashSet;
15use std::path::Path;
16
17/// Extract every entry for a package.
18pub fn extract(eco: Eco, pkg_name: &str, src: &Source, extra_types: Option<&Path>, upstream: Option<&Path>) -> Vec<Entry> {
19    let major: u64 = src.version.trim_start_matches('v').split('.').next().and_then(|m| m.parse().ok()).unwrap_or(0);
20    let jobs = plan(eco, src, extra_types, upstream, false);
21    let crate_name = if eco == Eco::Cargo {
22        rust_crate_name(&src.dir).unwrap_or_else(|| pkg_name.replace('-', "_"))
23    } else {
24        String::new()
25    };
26    let includes = upstream.map(Includes::scan).unwrap_or_default();
27    let mut all: Vec<Entry> = jobs
28        .par_iter()
29        .flat_map_iter(|job| {
30            let Ok(meta) = std::fs::metadata(&job.abs) else { return Vec::new() };
31            if meta.len() > MAX_FILE_BYTES && job.how != How::Prose {
32                return Vec::new();
33            }
34            let Ok(bytes) = std::fs::read(&job.abs) else { return Vec::new() };
35            let text = String::from_utf8_lossy(&bytes);
36            let mut out = Vec::new();
37            match job.how {
38                How::Prose => {
39                    prose(&text, &job.rel, 0, &mut out);
40                    if job.rel.starts_with("upstream:") && !includes.files.is_empty() {
41                        for e in &mut out {
42                            e.doc = includes.expand(&e.doc);
43                        }
44                    }
45                }
46                How::Page => {
47                    if let Some((md, title)) = page_markdown(&text) {
48                        let title = title.unwrap_or_else(|| page_title(&job.rel));
49                        prose_titled(&md, &job.rel, 0, Some(title), &mut out);
50                    }
51                }
52                How::Example => example(&text, &job.rel, &mut out),
53                How::Metadata => {
54                    let (body, line) = markdown::metadata_body(&text);
55                    prose(&body, &job.rel, line - 1, &mut out)
56                }
57                How::Ts => ts_file(&text, &job.rel, &mut out),
58                How::Python => py_file(&text, &job.rel, &mut out),
59                How::Rust => rs_file(&text, &job.rel, &crate_name, &mut out),
60                How::Go => go_file(&text, &job.rel, pkg_name, &mut out),
61            }
62            out
63        })
64        .collect();
65    for e in &mut all {
66        e.legacy = legacy_file(&e.file, major);
67    }
68    // Drop exact duplicates (the same declaration shipped twice).
69    let mut seen = HashSet::new();
70    all.retain(|e| seen.insert((e.path.clone(), e.sig.clone(), e.doc.len())));
71    all
72}
73
74/// A path segment `vN` with N below the package's major version.
75pub(super) fn legacy_file(file: &str, major: u64) -> bool {
76    major > 1
77        && file.split('/').any(|seg| {
78            seg.len() >= 2 && seg.starts_with('v') && seg[1..].chars().all(|c| c.is_ascii_digit()) && seg[1..].parse::<u64>().is_ok_and(|n| n < major)
79        })
80}