dx-forge 0.1.3

Production-ready VCS and orchestration engine for DX tools with Git-like versioning, dual-watcher architecture, traffic branch system, and component injection
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

use anyhow::Result;
use automerge::{transaction::Transactable, AutoCommit, ReadDoc, ROOT};
use parking_lot::RwLock;
use ropey::Rope;
use std::path::PathBuf;
use std::sync::Arc;

use super::operations::{Operation, OperationType, Position};

#[allow(dead_code)]
pub struct CrdtDocument {
    pub path: PathBuf,
    /// Automerge document for CRDT operations
    pub doc: Arc<RwLock<AutoCommit>>,
    /// Rope for efficient text editing
    pub rope: Arc<RwLock<Rope>>,
    /// Lamport timestamp for ordering
    pub lamport: Arc<parking_lot::Mutex<u64>>,
}

#[allow(dead_code)]
impl CrdtDocument {
    pub fn new(path: PathBuf, initial_content: &str) -> Self {
        let mut doc = AutoCommit::new();
        doc.put(ROOT, "content", initial_content).unwrap();

        Self {
            path,
            doc: Arc::new(RwLock::new(doc)),
            rope: Arc::new(RwLock::new(Rope::from_str(initial_content))),
            lamport: Arc::new(parking_lot::Mutex::new(0)),
        }
    }

    pub fn apply_operation(&self, op: &Operation) -> Result<()> {
        let mut lamport = self.lamport.lock();
        *lamport += 1;

        match &op.op_type {
            OperationType::Insert {
                position, content, ..
            } => {
                let mut rope = self.rope.write();
                let char_idx = self.line_col_to_char(&rope, position.line, position.column);
                rope.insert(char_idx, content);

                // Update CRDT
                let mut doc = self.doc.write();
                if let Some((value, _)) = doc.get(ROOT, "content")? {
                    let current: String = value.to_string();
                    let mut chars: Vec<char> = current.chars().collect();
                    chars.splice(char_idx..char_idx, content.chars());
                    doc.put(ROOT, "content", chars.iter().collect::<String>())?;
                }
            }

            OperationType::Delete { position, length } => {
                let mut rope = self.rope.write();
                let char_idx = self.line_col_to_char(&rope, position.line, position.column);
                rope.remove(char_idx..char_idx + length);

                // Update CRDT
                let mut doc = self.doc.write();
                if let Some((value, _)) = doc.get(ROOT, "content")? {
                    let current: String = value.to_string();
                    let mut chars: Vec<char> = current.chars().collect();
                    chars.drain(char_idx..char_idx + length);
                    doc.put(ROOT, "content", chars.iter().collect::<String>())?;
                }
            }

            OperationType::Replace {
                position,
                old_content,
                new_content,
            } => {
                let mut rope = self.rope.write();
                let char_idx = self.line_col_to_char(&rope, position.line, position.column);
                rope.remove(char_idx..char_idx + old_content.len());
                rope.insert(char_idx, new_content);

                // Update CRDT
                let mut doc = self.doc.write();
                if let Some((value, _)) = doc.get(ROOT, "content")? {
                    let current: String = value.to_string();
                    let mut chars: Vec<char> = current.chars().collect();
                    chars.splice(char_idx..char_idx + old_content.len(), new_content.chars());
                    doc.put(ROOT, "content", chars.iter().collect::<String>())?;
                }
            }

            _ => {}
        }

        Ok(())
    }

    pub fn get_content(&self) -> String {
        self.rope.read().to_string()
    }

    pub fn create_position(&self, line: usize, column: usize, actor_id: String) -> Position {
        let rope = self.rope.read();
        let offset = self.line_col_to_char(&rope, line, column);
        let lamport = *self.lamport.lock();

        Position::new(line, column, offset, actor_id, lamport)
    }

    fn line_col_to_char(&self, rope: &Rope, line: usize, col: usize) -> usize {
        rope.line_to_char(line.saturating_sub(1)) + col.saturating_sub(1)
    }

    /// Get the current position from a stable anchor
    pub fn resolve_anchor(&self, _stable_id: &str) -> Option<(usize, usize)> {
        // This would use the CRDT's operation history to resolve
        // the current position of an anchor
        // For now, simplified implementation
        None
    }
}