...

doctree/src/doctree.rs

@@ -38,6 +38,9 @@ pub struct DocTree {
     /// Redis storage backend
     storage: RedisStorage,
     
+    /// Name of the doctree (used as prefix for Redis keys)
+    pub doctree_name: String,
+    
     /// For backward compatibility
     pub name: String,
     
@@ -56,6 +59,9 @@ pub struct DocTreeBuilder {
     /// Redis storage backend
     storage: Option<RedisStorage>,
     
+    /// Name of the doctree (used as prefix for Redis keys)
+    doctree_name: Option<String>,
+    
     /// For backward compatibility
     name: Option<String>,
     
@@ -74,6 +80,7 @@ impl DocTree {
             collections: HashMap::new(),
             default_collection: None,
             storage: None,
+            doctree_name: Some("default".to_string()),
             name: None,
             path: None,
         }
@@ -92,8 +99,12 @@ impl DocTree {
     pub fn add_collection<P: AsRef<Path>>(&mut self, path: P, name: &str) -> Result<&Collection> {
         // Create a new collection
         let namefixed = name_fix(name);
+        // Clone the storage and set the doctree name
+        let mut storage = self.storage.clone();
+        storage.set_doctree_name(&self.doctree_name);
+        
         let collection = Collection::builder(path, &namefixed)
-            .with_storage(self.storage.clone())
+            .with_storage(storage)
             .build()?;
         
         // Scan the collection
@@ -531,6 +542,20 @@ impl DocTreeBuilder {
     /// # Returns
     ///
     /// Self for method chaining
+    /// Set the doctree name
+    ///
+    /// # Arguments
+    ///
+    /// * `name` - Name of the doctree
+    ///
+    /// # Returns
+    ///
+    /// Self for method chaining
+    pub fn with_doctree_name(mut self, name: &str) -> Self {
+        self.doctree_name = Some(name.to_string());
+        self
+    }
+    
     pub fn with_storage(mut self, storage: RedisStorage) -> Self {
         self.storage = Some(storage);
         self
@@ -552,10 +577,18 @@ impl DocTreeBuilder {
             DocTreeError::MissingParameter("storage".to_string())
         })?;
         
+        // Get the doctree name
+        let doctree_name = self.doctree_name.clone().unwrap_or_else(|| "default".to_string());
+        
         // Create a new collection
         let namefixed = name_fix(name);
+        
+        // Clone the storage and set the doctree name
+        let mut storage_clone = storage.clone();
+        storage_clone.set_doctree_name(&doctree_name);
+        
         let collection = Collection::builder(path.as_ref(), &namefixed)
-            .with_storage(storage.clone())
+            .with_storage(storage_clone)
             .build()?;
         
         // Scan the collection
@@ -604,11 +637,19 @@ impl DocTreeBuilder {
             DocTreeError::MissingParameter("storage".to_string())
         })?;
         
+        // Get the doctree name
+        let doctree_name = self.doctree_name.clone().unwrap_or_else(|| "default".to_string());
+        
+        // Clone the storage and set the doctree name
+        let mut storage_clone = storage.clone();
+        storage_clone.set_doctree_name(&doctree_name);
+        
         // Create a temporary DocTree to scan collections
         let mut temp_doctree = DocTree {
             collections: HashMap::new(),
             default_collection: None,
-            storage: storage.clone(),
+            storage: storage_clone,
+            doctree_name: doctree_name,
             name: self.name.clone().unwrap_or_default(),
             path: self.path.clone().unwrap_or_else(|| PathBuf::from("")),
         };
@@ -641,11 +682,19 @@ impl DocTreeBuilder {
             DocTreeError::MissingParameter("storage".to_string())
         })?;
         
+        // Get the doctree name
+        let doctree_name = self.doctree_name.unwrap_or_else(|| "default".to_string());
+        
+        // Set the doctree name in the storage
+        let mut storage_clone = storage.clone();
+        storage_clone.set_doctree_name(&doctree_name);
+        
         // Create the DocTree
         let mut doctree = DocTree {
             collections: self.collections,
             default_collection: self.default_collection,
-            storage: storage.clone(),
+            storage: storage_clone,
+            doctree_name,
             name: self.name.unwrap_or_default(),
             path: self.path.unwrap_or_else(|| PathBuf::from("")),
         };
@@ -684,6 +733,12 @@ pub fn new<P: AsRef<Path>>(args: &[&str]) -> Result<DocTree> {
     
     let mut builder = DocTree::builder().with_storage(storage);
     
+    // If the first argument is a doctree name, use it
+    if args.len() >= 1 && args[0].starts_with("--doctree=") {
+        let doctree_name = args[0].trim_start_matches("--doctree=");
+        builder = builder.with_doctree_name(doctree_name);
+    }
+    
     // For backward compatibility with existing code
     if args.len() == 2 {
         let path = args[0];
@@ -707,15 +762,20 @@ pub fn new<P: AsRef<Path>>(args: &[&str]) -> Result<DocTree> {
 /// # Arguments
 ///
 /// * `root_path` - The root path to scan for collections
+/// * `doctree_name` - Optional name for the doctree (default: "default")
 ///
 /// # Returns
 ///
 /// A new DocTree or an error
-pub fn from_directory<P: AsRef<Path>>(root_path: P) -> Result<DocTree> {
+pub fn from_directory<P: AsRef<Path>>(root_path: P, doctree_name: Option<&str>) -> Result<DocTree> {
     let storage = RedisStorage::new("redis://localhost:6379")?;
     
-    DocTree::builder()
-        .with_storage(storage)
-        .scan_collections(root_path)?
-        .build()
+    let mut builder = DocTree::builder().with_storage(storage);
+    
+    // Set the doctree name if provided
+    if let Some(name) = doctree_name {
+        builder = builder.with_doctree_name(name);
+    }
+    
+    builder.scan_collections(root_path)?.build()
 }