Rust के साथ मोनोरेपॉजिटरी: व्यवहार में कोड का संगठन

Rust के साथ मोनोरेपॉजिटरी: व्यवहार में कोड का संगठन

Rust में बड़े प्रोजेक्ट्स विकसित करते समय, देर-सबेर यह सवाल उठता है: कोड को कैसे व्यवस्थित किया जाए ताकि वह बनाए रखने योग्य, पुन: प्रयोग करने योग्य और आसानी से स्केलेबल बना रहे? एक लोकप्रिय दृष्टिकोण है मोनोरेपॉजिटरी। इस लेख में, हम चर्चा करेंगे कि Rust के संदर्भ में मोनोरेपॉजिटरी क्या है, इसे Cargo Workspaces की मदद से कैसे सेट अप करें, और कौन सी व्यावहारिक तकनीकें कोडबेस में अव्यवस्था से बचने में मदद करेंगी।

यह सामग्री शुरुआती लोगों के लिए उपयोगी होगी जो अभी बड़े प्रोजेक्ट्स के साथ काम करना शुरू कर रहे हैं, साथ ही अनुभवी डेवलपर्स के लिए भी जो कोड संगठन के प्रभावी तरीकों की तलाश कर रहे हैं।

मोनोरेपॉजिटरी क्या है और Rust में इसकी आवश्यकता क्यों है?

मोनोरेपॉजिटरी (monorepo) एक ऐसा दृष्टिकोण है जिसमें प्रोजेक्ट का सारा कोड (या कई संबंधित प्रोजेक्ट्स) एक ही रिपॉजिटरी में संग्रहीत किया जाता है। मल्टीरेपॉजिटरी के विपरीत, जहां प्रत्येक सेवा या लाइब्रेरी एक अलग Git रिपॉजिटरी में रहती है।

Rust डेवलपर्स अक्सर मोनोरेपॉजिटरी क्यों चुनते हैं?

\n
• निर्भरताओं का एकीकृत संस्करण। आप उन विरोधों से बचते हैं जहां विभिन्न क्रेट्स एक ही लाइब्रेरी के अलग-अलग संस्करणों की मांग करते हैं।
\n
• सरलीकृत रीफैक्टरिंग। एक क्रेट में API में बदलाव तुरंत सभी आश्रित क्रेट्स में दिखाई देता है - Rust कंपाइलर उन सभी स्थानों को इंगित करेगा जिन्हें ठीक करने की आवश्यकता है।
\n
• सहयोगात्मक संकलन। Cargo पहले से संकलित आर्टिफैक्ट्स का पुन: उपयोग करके बिल्ड को अनुकूलित कर सकता है।
\n
• परिवर्तनों का एकीकृत इतिहास। आपको विभिन्न रिपॉजिटरीज़ के बीच कमिट को सिंक्रोनाइज़ करने की आवश्यकता नहीं है।
\n

Rust में मोनोरेपॉजिटरी को व्यवस्थित करने का मुख्य उपकरण Cargo Workspaces है। आइए देखें कि व्यवहार में इसका उपयोग कैसे करें।

Cargo Workspaces सेट अप करना: चरण-दर-चरण उदाहरण

मान लीजिए, हम एक ऐसा एप्लिकेशन बना रहे हैं जिसमें तीन भाग हैं:

\n
• लाइब्रेरी core_lib — सामान्य तर्क;
\n
• लाइब्रेरी utils — उपयोगिताएँ;
\n
• निष्पादन योग्य फ़ाइल app — मुख्य बाइनरी।
\n

मोनोरेपॉजिटरी संरचना बनाएँ:

my_monorepo/\n├── Cargo.toml          # रूट workspace मेनिफेस्ट\n├── core_lib/\n│   ├── Cargo.toml\n│   └── src/\n│       └── lib.rs\n├── utils/\n│   ├── Cargo.toml\n│   └── src/\n│       └── lib.rs\n└── app/\n    ├── Cargo.toml\n    └── src/\n        └── main.rs\n

चरण 1. रूट Cargo.toml

[workspace]\nmembers = [\n    "core_lib",\n    "utils",\n    "app",\n]\n

अब तीनों क्रेट एक ही workspace का हिस्सा हैं। Cargo उन्हें एक इकाई के रूप में प्रबंधित करेगा।

चरण 2. आंतरिक निर्भरताएँ

फ़ाइल app/Cargo.toml में, हम निर्दिष्ट करेंगे कि यह हमारी लाइब्रेरीज़ पर निर्भर है:

[package]\nname = "app"\nversion = "0.1.0"\nedition = "2021"\n\n[dependencies]\ncore_lib = { path = "../core_lib" }\nutils = { path = "../utils" }\n

चरण 3. कोड लिखना

core_lib/src/lib.rs में कोड का उदाहरण:

pub fn greet(name: &str) -> String {\n    format!("Hello, {}!", name)\n}\n

app/src/main.rs में इस फ़ंक्शन का उपयोग करें:

use core_lib::greet;\n\nfn main() {\n    println!("{}", greet("Rust Developer"));\n}\n

चरण 4. बिल्ड और रन

कमांड cargo build, cargo test और cargo run पूरे workspace के लिए काम करते हैं। आप एक विशिष्ट क्रेट भी चला सकते हैं:

cargo run -p app\ncargo test -p core_lib\n

यह बुनियादी सेटअप है। अब अधिक उन्नत प्रथाओं पर चलते हैं।

उन्नत संगठन: मॉड्यूल, परीक्षण और संस्करण नियंत्रण

जब क्रेट्स की संख्या बढ़ जाती है, तो अनुशासन बनाए रखना महत्वपूर्ण है। यहाँ कुछ सुझाव दिए गए हैं: