rune/cli/
loader.rs

Help
1use std::ffi::OsStr;
2use std::fs;
3use std::io;
4use std::path::PathBuf;
5use std::{path::Path, sync::Arc};
6
7use anyhow::{anyhow, Context as _, Result};
8
9use crate::alloc::{Vec, VecDeque};
10use crate::cli::{visitor, Io, SharedFlags};
11use crate::compile::FileSourceLoader;
12use crate::{Context, Diagnostics, Hash, ItemBuf, Options, Source, Sources, Unit};
13
14pub(super) struct Load {
15    pub(super) unit: Arc<Unit>,
16    pub(super) sources: Sources,
17    pub(super) functions: Vec<(Hash, ItemBuf)>,
18}
19
20/// Load context and code for a given path
21pub(super) fn load(
22    io: &mut Io<'_>,
23    context: &Context,
24    shared: &SharedFlags,
25    options: &Options,
26    path: &Path,
27    attribute: visitor::Attribute,
28) -> Result<Load> {
29    let bytecode_path = path.with_extension("rnc");
30
31    let source =
32        Source::from_path(path).with_context(|| anyhow!("cannot read file: {}", path.display()))?;
33
34    let mut sources = Sources::new();
35    sources.insert(source)?;
36
37    let use_cache = options.bytecode && should_cache_be_used(path, &bytecode_path)?;
38
39    // TODO: how do we deal with tests discovery for bytecode loading
40    let maybe_unit = if use_cache {
41        let f = fs::File::open(&bytecode_path)?;
42
43        match bincode::deserialize_from::<_, Unit>(f) {
44            Ok(unit) => {
45                tracing::trace!("Using cache: {}", bytecode_path.display());
46                Some(Arc::new(unit))
47            }
48            Err(_error) => {
49                tracing::error!(
50                    "Failed to deserialize: {}: {}",
51                    bytecode_path.display(),
52                    _error
53                );
54                None
55            }
56        }
57    } else {
58        None
59    };
60
61    let (unit, functions) = match maybe_unit {
62        Some(unit) => (unit, Default::default()),
63        None => {
64            tracing::trace!("building file: {}", path.display());
65
66            let mut diagnostics = if shared.warnings {
67                Diagnostics::new()
68            } else {
69                Diagnostics::without_warnings()
70            };
71
72            let mut functions = visitor::FunctionVisitor::new(attribute);
73            let mut source_loader = FileSourceLoader::new();
74
75            let result = crate::prepare(&mut sources)
76                .with_context(context)
77                .with_diagnostics(&mut diagnostics)
78                .with_options(options)
79                .with_visitor(&mut functions)?
80                .with_source_loader(&mut source_loader)
81                .build();
82
83            diagnostics.emit(io.stdout, &sources)?;
84            let unit = result?;
85
86            if options.bytecode {
87                tracing::trace!("serializing cache: {}", bytecode_path.display());
88                let f = fs::File::create(&bytecode_path)?;
89                bincode::serialize_into(f, &unit)?;
90            }
91
92            (Arc::new(unit), functions.into_functions())
93        }
94    };
95
96    Ok(Load {
97        unit,
98        sources,
99        functions,
100    })
101}
102
103/// Test if path `a` is newer than path `b`.
104fn should_cache_be_used(source: &Path, cached: &Path) -> io::Result<bool> {
105    let source = fs::metadata(source)?;
106
107    let cached = match fs::metadata(cached) {
108        Ok(cached) => cached,
109        Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(false),
110        Err(error) => return Err(error),
111    };
112
113    Ok(source.modified()? < cached.modified()?)
114}
115
116pub(super) fn recurse_paths(
117    recursive: bool,
118    first: PathBuf,
119) -> impl Iterator<Item = Result<PathBuf>> {
120    let mut queue = VecDeque::new();
121    let mut first = Some(first);
122
123    std::iter::from_fn(move || loop {
124        let path = first.take().or_else(|| queue.pop_front())?;
125
126        if !recursive {
127            return Some(Ok(path));
128        }
129
130        if path.is_file() {
131            if path.extension() == Some(OsStr::new("rn")) {
132                return Some(Ok(path));
133            }
134
135            continue;
136        }
137
138        let d = match fs::read_dir(path) {
139            Ok(d) => d,
140            Err(error) => return Some(Err(anyhow::Error::from(error))),
141        };
142
143        for e in d {
144            let e = match e {
145                Ok(e) => e,
146                Err(error) => return Some(Err(anyhow::Error::from(error))),
147            };
148
149            if let Err(error) = queue.try_push_back(e.path()) {
150                return Some(Err(anyhow::Error::from(error)));
151            }
152        }
153    })
154}
rune/cli/loader.rs

rune/cli/
loader.rs
