gramr 0.1.0

⚔️ 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

use crate::{
    project::Project, templates::SolidityTemplate, GramrError, Language, ProjectType, Result,
};

/// Abstract contract generator for creating empty abstract contracts
pub struct AbstractContractGenerator {
    project: ProjectType,
    language: Language,
    name: String,
    pragma: Option<String>,
    license: Option<String>,
}

impl AbstractContractGenerator {
    /// Create a new abstract contract generator
    pub fn new(
        project: ProjectType,
        language: Language,
        name: String,
        pragma: Option<String>,
        license: Option<String>,
    ) -> Self {
        Self {
            project,
            language,
            name,
            pragma,
            license,
        }
    }

    /// Generate the abstract contract
    pub fn generate(&self) -> Result<()> {
        match self.language {
            Language::Solidity => self.generate_solidity_abstract(),
            Language::RustStylus => self.generate_rust_abstract(),
        }
    }

    fn generate_solidity_abstract(&self) -> Result<()> {
        let pragma = self.pragma.as_deref().unwrap_or("0.8.30");
        let license = self.license.as_deref().unwrap_or("UNLICENSED");

        let template = SolidityTemplate::new(
            self.name.clone(),
            crate::templates::ContractType::Abstract,
            pragma.to_string(),
            license.to_string(),
        );

        let content = template.generate_abstract_contract();

        match &self.project {
            ProjectType::Foundry(foundry) => {
                let abstracts_dir = foundry.src_dir().join("abstracts");
                std::fs::create_dir_all(&abstracts_dir)?;

                let file_path = abstracts_dir.join(format!("{}.sol", self.name));
                std::fs::write(file_path, content)?;

                println!("✅ Abstract contract {} created successfully!", self.name);
                Ok(())
            }
            ProjectType::Cargo(_) => Err(GramrError::Other(
                "Abstract contract generation for Rust/Stylus projects is not yet supported"
                    .to_string(),
            )),
        }
    }

    fn generate_rust_abstract(&self) -> Result<()> {
        // For now, return an error since Rust/Stylus abstract contracts might work differently
        Err(GramrError::Other(
            "Abstract contract generation for Rust/Stylus projects is not yet supported. Use traits for similar patterns.".to_string()
        ))
    }
}