gramr 0.0.1

⚔️ A blazing-fast library for scaffolding smart contracts
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use crate::error::{GramrError, Result};
use crate::project::Project;
use std::fs;
use std::path::{Path, PathBuf};
use which::which;

#[derive(Clone)]
pub struct FoundryProject {
    pub root: PathBuf,
    pub src_dir: PathBuf,
    pub test_dir: PathBuf,
    pub script_dir: PathBuf,
}

impl FoundryProject {
    pub fn detect() -> Result<Self> {
        let current_dir = std::env::current_dir()?;

        if !Self::has_forge()? {
            return Err(GramrError::FoundryNotInstalled);
        }

        let root = Self::find_foundry_root(&current_dir)?;

        let src_dir = root.join("src");
        let test_dir = root.join("test");
        let script_dir = root.join("script");

        Ok(Self {
            root,
            src_dir,
            test_dir,
            script_dir,
        })
    }

    fn has_forge() -> Result<bool> {
        Ok(which("forge").is_ok())
    }

    fn find_foundry_root(start_dir: &Path) -> Result<PathBuf> {
        let mut current = start_dir.to_path_buf();

        loop {
            if current.join("foundry.toml").exists() {
                return Ok(current);
            }

            if !current.pop() {
                return Err(GramrError::NotFoundryProject);
            }
        }
    }

    pub fn ensure_directories(&self) -> Result<()> {
        fs::create_dir_all(&self.src_dir)?;
        fs::create_dir_all(&self.test_dir)?;
        fs::create_dir_all(&self.script_dir)?;
        Ok(())
    }

    pub fn has_openzeppelin(&self) -> bool {
        self.root.join("lib/openzeppelin-contracts").exists()
    }

    pub fn has_openzeppelin_upgradeable(&self) -> bool {
        self.root
            .join("lib/openzeppelin-contracts-upgradeable")
            .exists()
    }

    pub fn install_openzeppelin(&self) -> Result<()> {
        use std::process::Command;

        let output = Command::new("forge")
            .args(&["install", "OpenZeppelin/openzeppelin-contracts"])
            .current_dir(&self.root)
            .output()?;

        if !output.status.success() {
            return Err(GramrError::ForgeCommandError(
                String::from_utf8_lossy(&output.stderr).to_string(),
            ));
        }

        Ok(())
    }

    pub fn install_openzeppelin_upgradeable(&self) -> Result<()> {
        use std::process::Command;

        let output = Command::new("forge")
            .args(&["install", "OpenZeppelin/openzeppelin-contracts-upgradeable"])
            .current_dir(&self.root)
            .output()?;

        if !output.status.success() {
            return Err(GramrError::ForgeCommandError(
                String::from_utf8_lossy(&output.stderr).to_string(),
            ));
        }

        Ok(())
    }
}

impl Project for FoundryProject {
    fn ensure_directories(&self) -> Result<()> {
        self.ensure_directories()
    }

    fn src_dir(&self) -> PathBuf {
        self.src_dir.clone()
    }

    fn test_dir(&self) -> PathBuf {
        self.test_dir.clone()
    }

    fn script_dir(&self) -> PathBuf {
        self.script_dir.clone()
    }

    fn has_openzeppelin(&self) -> bool {
        self.has_openzeppelin()
    }

    fn install_openzeppelin(&self) -> Result<()> {
        self.install_openzeppelin()
    }

    fn has_openzeppelin_upgradeable(&self) -> bool {
        self.has_openzeppelin_upgradeable()
    }

    fn install_openzeppelin_upgradeable(&self) -> Result<()> {
        self.install_openzeppelin_upgradeable()
    }
}