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

use crate::error::{GramrError, Result};
use crate::language::Language;
use crate::project::{Project, ProjectType};
use crate::templates::{Template, SolidityTemplate, StylusTemplate, ContractType};
use colored::*;
use std::fs;

pub struct LibraryGenerator {
    project: ProjectType,
    language: Language,
    library_name: String,
    pragma: Option<String>,  // Only for Solidity
    license: Option<String>, // Only for Solidity
}

impl LibraryGenerator {
    pub fn new(
        project: ProjectType,
        language: Language,
        library_name: String,
        pragma: Option<String>,
        license: Option<String>,
    ) -> Self {
        Self {
            project,
            language,
            library_name,
            pragma,
            license,
        }
    }

    pub fn generate(&self) -> Result<()> {
        self.validate_name()?;
        self.project.ensure_directories()?;
        
        // Ensure libraries directory exists
        self.ensure_libraries_directory()?;

        let template: Box<dyn Template> = match self.language {
            Language::Solidity => {
                Box::new(SolidityTemplate::new(
                    self.library_name.clone(),
                    ContractType::Basic, // Libraries don't use contract types
                    self.pragma.clone().unwrap_or_else(|| "0.8.30".to_string()),
                    self.license.clone().unwrap_or_else(|| "UNLICENSED".to_string()),
                ))
            }
            Language::RustStylus => {
                Box::new(StylusTemplate::new(
                    self.library_name.clone(),
                    ContractType::Basic, // Libraries don't use contract types
                ))
            }
        };

        self.create_library_file(&*template)?;
        self.print_success();
        Ok(())
    }

    fn validate_name(&self) -> Result<()> {
        if self.library_name.is_empty() {
            return Err(GramrError::Other("Library name cannot be empty".to_string()));
        }

        if !self.library_name.chars().next().unwrap().is_alphabetic() {
            return Err(GramrError::Other(
                "Library name must start with a letter".to_string()
            ));
        }

        if !self.library_name.chars().all(|c| c.is_alphanumeric() || c == '_') {
            return Err(GramrError::Other(
                "Library name can only contain letters, numbers, and underscores".to_string()
            ));
        }

        Ok(())
    }

    fn ensure_libraries_directory(&self) -> Result<()> {
        let libraries_dir = match self.language {
            Language::Solidity => self.project.src_dir().join("libraries"),
            Language::RustStylus => self.project.src_dir().join("libraries"),
        };

        fs::create_dir_all(&libraries_dir)
            .map_err(|e| GramrError::Other(format!("Failed to create libraries directory: {}", e)))?;
        
        Ok(())
    }

    fn create_library_file(&self, template: &dyn Template) -> Result<()> {
        let content = template.generate_library();
        let (file_path, relative_path) = match self.language {
            Language::Solidity => {
                let file_name = format!("{}.sol", self.library_name);
                let path = self.project.src_dir().join("libraries").join(&file_name);
                let relative = format!("src/libraries/{}", file_name);
                (path, relative)
            }
            Language::RustStylus => {
                let file_name = format!("{}.rs", self.library_name.to_lowercase());
                let path = self.project.src_dir().join("libraries").join(&file_name);
                let relative = format!("src/libraries/{}", file_name);
                (path, relative)
            }
        };
        
        fs::write(&file_path, content)
            .map_err(|e| GramrError::Other(format!("Failed to write library file: {}", e)))?;
        
        println!("{} Created library: {}", "✓".green(), relative_path);
        Ok(())
    }

    fn print_success(&self) {
        println!("\n{} Library generation complete!", "📚".bold());
        println!("\nNext steps:");
        println!("  1. Review the generated library file");
        println!("  2. Add your custom functions and data structures");
        
        match self.language {
            Language::Solidity => {
                println!("  3. Import in contracts with: {}", format!("import \"./libraries/{}.sol\";", self.library_name).cyan());
                println!("  4. Use library functions with: {}", format!("using {} for <Type>;", self.library_name).cyan());
                println!("  5. Run {} to compile", "forge build".cyan());
            }
            Language::RustStylus => {
                println!("  3. Add to lib.rs: {}", format!("pub mod libraries;").cyan());
                println!("  4. Import in contracts with: {}", format!("use crate::libraries::{};", self.library_name.to_lowercase()).cyan());
                println!("  5. Run {} to build", "cargo build --release".cyan());
            }
        }
    }
}