static_files/mods/
resource_dir.rs

1use std::{
2    env, io,
3    path::{Path, PathBuf},
4};
5
6use super::sets::{generate_resources_sets, SplitByCount};
7
8/// Generate resources for `resource_dir`.
9///
10/// ```rust
11/// // Generate resources for ./tests dir with file name generated.rs
12/// // stored in path defined by OUT_DIR environment variable.
13/// // Function name is 'generate'
14/// use static_files::resource_dir;
15///
16/// resource_dir("./tests").build().unwrap();
17/// ```
18pub fn resource_dir<P: AsRef<Path>>(resource_dir: P) -> ResourceDir {
19    ResourceDir {
20        resource_dir: resource_dir.as_ref().into(),
21        ..Default::default()
22    }
23}
24
25/// Resource dir.
26///
27/// A builder structure allows to change default settings for:
28/// - file filter
29/// - generated file name
30/// - generated function name
31#[derive(Default)]
32pub struct ResourceDir {
33    pub(crate) resource_dir: PathBuf,
34    pub(crate) filter: Option<fn(p: &Path) -> bool>,
35    pub(crate) generated_filename: Option<PathBuf>,
36    pub(crate) generated_fn: Option<String>,
37    pub(crate) module_name: Option<String>,
38    pub(crate) count_per_module: Option<usize>,
39}
40
41pub const DEFAULT_MODULE_NAME: &str = "sets";
42pub const DEFAULT_COUNT_PER_MODULE: usize = 256;
43
44impl ResourceDir {
45    /// Generates resources for current configuration.
46    ///
47    /// # Panics
48    /// Panics if `OUT_DIR` environment variable is not set.
49    pub fn build(self) -> io::Result<()> {
50        let generated_filename = self.generated_filename.unwrap_or_else(|| {
51            let out_dir = env::var("OUT_DIR").unwrap();
52
53            Path::new(&out_dir).join("generated.rs")
54        });
55        let generated_fn = self.generated_fn.unwrap_or_else(|| "generate".into());
56
57        let module_name = self
58            .module_name
59            .unwrap_or_else(|| format!("{generated_fn}_{DEFAULT_MODULE_NAME}"));
60
61        let count_per_module = self.count_per_module.unwrap_or(DEFAULT_COUNT_PER_MODULE);
62
63        generate_resources_sets(
64            &self.resource_dir,
65            self.filter,
66            generated_filename,
67            module_name.as_str(),
68            &generated_fn,
69            &mut SplitByCount::new(count_per_module),
70        )
71    }
72
73    /// Sets the file filter.
74    pub fn with_filter(&mut self, filter: fn(p: &Path) -> bool) -> &mut Self {
75        self.filter = Some(filter);
76        self
77    }
78
79    /// Sets the generated filename.
80    pub fn with_generated_filename<P: AsRef<Path>>(&mut self, generated_filename: P) -> &mut Self {
81        self.generated_filename = Some(generated_filename.as_ref().into());
82        self
83    }
84
85    /// Sets the generated function name.
86    pub fn with_generated_fn<S>(&mut self, generated_fn: S) -> &mut Self
87    where
88        S: Into<String>,
89    {
90        self.generated_fn = Some(generated_fn.into());
91        self
92    }
93
94    /// Sets the generated module name.
95    ///
96    /// Default value is based on generated function name and the suffix "sets".
97    /// Generated module would be overriden by each call.
98    pub fn with_module_name<S>(&mut self, module_name: S) -> &mut Self
99    where
100        S: Into<String>,
101    {
102        self.module_name = Some(module_name.into());
103        self
104    }
105
106    /// Sets maximal count of files per module.
107    pub fn with_count_per_module(&mut self, count_per_module: usize) -> &mut Self {
108        self.count_per_module = Some(count_per_module);
109        self
110    }
111}