ognibuild 0.2.11

Detect and run any build system
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! VCS-related functions
use breezyshim::branch::Branch;
use breezyshim::error::Error as BrzError;
use breezyshim::prelude::Repository;
use breezyshim::tree::PyTree;
use breezyshim::workingtree::{GenericWorkingTree, WorkingTree};
use std::path::{Path, PathBuf};
use url::Url;

/// Export a VCS tree to a new location.
///
/// # Arguments
/// * `tree` - The tree to export
/// * `directory` - The directory to export the tree to
/// * `subpath` - The subpath to export
pub fn export_vcs_tree<T: PyTree>(
    tree: &T,
    directory: &Path,
    subpath: Option<&Path>,
) -> Result<(), BrzError> {
    breezyshim::export::export(tree, directory, subpath)
}

/// A Breezy tree that can be duplicated.
pub trait DupableTree {
    /// Get the basis tree of this tree.
    fn basis_tree(&self) -> breezyshim::tree::RevisionTree;

    /// Get the parent location of this tree.
    fn get_parent(&self) -> Option<String>;

    /// Get the base directory of this tree, if it has one.
    fn basedir(&self) -> Option<PathBuf>;

    /// Export this tree to a directory.
    fn export_to(&self, directory: &Path, subpath: Option<&Path>) -> Result<(), BrzError>;
}

impl DupableTree for GenericWorkingTree {
    fn basis_tree(&self) -> breezyshim::tree::RevisionTree {
        WorkingTree::basis_tree(self).unwrap()
    }

    fn get_parent(&self) -> Option<String> {
        WorkingTree::branch(self).get_parent()
    }

    fn basedir(&self) -> Option<PathBuf> {
        Some(WorkingTree::basedir(self))
    }

    fn export_to(&self, directory: &Path, subpath: Option<&Path>) -> Result<(), BrzError> {
        export_vcs_tree(self, directory, subpath)
    }
}

impl DupableTree for breezyshim::tree::RevisionTree {
    fn basis_tree(&self) -> breezyshim::tree::RevisionTree {
        self.repository()
            .revision_tree(&self.get_revision_id())
            .unwrap()
    }

    fn get_parent(&self) -> Option<String> {
        let branch = self.repository().controldir().open_branch(None).unwrap();

        branch.get_parent()
    }

    fn basedir(&self) -> Option<PathBuf> {
        None
    }

    fn export_to(&self, directory: &Path, subpath: Option<&Path>) -> Result<(), BrzError> {
        export_vcs_tree(self, directory, subpath)
    }
}

/// Duplicate a VCS tree to a new location, including all history.
///
/// For a RevisionTree, this will duplicate the tree to a new location.
/// For a WorkingTree, this will duplicate the basis tree to a new location.
///
/// # Arguments
/// * `orig_tree` - The tree to duplicate
/// * `directory` - The directory to duplicate the tree to
pub fn dupe_vcs_tree(orig_tree: &dyn DupableTree, directory: &Path) -> Result<(), BrzError> {
    let tree = orig_tree.basis_tree();
    let result = tree.repository().controldir().sprout(
        Url::from_directory_path(directory).unwrap(),
        None,
        Some(true),
        None,
        Some(&tree.get_revision_id()),
    )?;

    assert!(result.has_workingtree());

    // Copy parent location - some scripts need this
    if let Some(parent) = orig_tree.get_parent() {
        let mut branch = result.open_branch(None)?;
        branch.set_parent(&parent);
    }

    Ok(())
}