assemble-std 0.2.0

The standard library for assemble
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

//! Define the DupeSpec

use assemble_core::file_collection::FileSet;
use assemble_core::project::VisitProject;
use assemble_core::utilities::{Spec, Work};
use assemble_core::Project;
use std::path::{Path, PathBuf};

/// A dupe spec is used for copying files around. All values (besides children) are inherited
/// by children specs unless specified otherwise. Include and Excludes are always inherited
pub struct DupeSpec {
    /// The files to copy from. If not set, uses the parent spec
    from: Option<FileSet>,
    /// The target directory to copy files in. If not set, uses the parent spec
    into: Option<PathBuf>,
    /// Filters which files to include
    include: Box<dyn Spec<Path>>,
    /// Filters which files should be excluded.
    ///
    /// Only files which pass the included filter are tested to be excluded.
    exclude: Box<dyn Spec<Path>>,
    parent: Option<Box<DupeSpec>>,
}

impl DupeSpec {
    fn get_from(&self) -> Option<&FileSet> {
        self.from
            .as_ref()
            .or_else(|| self.parent.as_ref().and_then(|p| p.get_from()))
    }

    fn get_into(&self) -> Option<&Path> {
        self.into
            .as_deref()
            .or_else(|| self.parent.as_ref().and_then(|p| p.get_into()))
    }

    fn is_included(&self, path: &Path) -> bool {
        if let Some(parent) = &self.parent {
            if !parent.is_included(path) {
                return false;
            }
        }
        self.include.accept(path) && !self.exclude.accept(path)
    }

    // fn copy(&self, from: ) -> Work {
    //     todo!()
    // }
}

impl VisitProject<Work> for DupeSpec {
    fn visit(&mut self, _project: &Project) -> Work {
        todo!()
    }
}