04b1546 · helix · git.iko.soy

1use crate::{ChangeSet, Rope, State, Transaction};

2+use smallvec::{smallvec, SmallVec};

2

3

3/// Undo-tree style history store.

4/// Undo-tree style history store.

4pub struct History {

5pub struct History {

5 revisions: Vec<Revision>,

6 revisions: Vec<Revision>,

6 cursor: usize,

7 cursor: usize,

7− //

8}

9

10#[derive(Debug)]

11struct Revision {

12− // prev: usize,

13 parent: usize,

12 parent: usize,

13+ children: SmallVec<[(usize, Transaction); 1]>,

14 /// The transaction to revert to previous state.

15 revert: Transaction,

16 // selection before, selection after?

22 Self {

23 revisions: vec![Revision {

24 parent: 0,

25+ children: SmallVec::new(),

25 revert: Transaction::from(ChangeSet::new(&Rope::new())),

26 revert: Transaction::from(ChangeSet::new(&Rope::new())),

26 }],

27 }],

27 cursor: 0,

28 cursor: 0,

31

32

32impl History {

33impl History {

33 pub fn commit_revision(&mut self, transaction: &Transaction, original: &State) {

34 pub fn commit_revision(&mut self, transaction: &Transaction, original: &State) {

34− // TODO: store both directions

35− // TODO: could store a single set if deletes also stored the text they delete

35+ // TODO: could store a single transaction, if deletes also stored the text they delete

36 let revert = transaction.invert(original);

37

38 let new_cursor = self.revisions.len();

39 self.revisions.push(Revision {

40 parent: self.cursor,

41+ children: SmallVec::new(),

41 revert,

42 revert,

42 });

43 });

43− self.cursor = new_cursor;

44

45− // TODO: child tracking too?

45+ // add a reference to the parent

46+ self.revisions

47+ .get_mut(self.cursor)

48+ .unwrap() // TODO: get_unchecked_mut

49+ .children

50+ .push((new_cursor, transaction.clone()));

51+

52+ self.cursor = new_cursor;

46 }

53 }

47

54

48 #[inline]

55 #[inline]

57 }

64 }

58

65

59 let current_revision = &self.revisions[self.cursor];

66 let current_revision = &self.revisions[self.cursor];

60− // unimplemented!("{:?}", revision);

67+

61− // unimplemented!("{:?}", state.doc().len_chars());

62− // TODO: pass the return value through?

68+ // TODO: pass the return value through? It should always succeed

63 let success = current_revision.revert.apply(state);

69 let success = current_revision.revert.apply(state);

64

70

65 if !success {

71 if !success {

72 pub fn redo(&mut self, state: &mut State) {

78 pub fn redo(&mut self, state: &mut State) {

73 let current_revision = &self.revisions[self.cursor];

79 let current_revision = &self.revisions[self.cursor];

74

80

75− // TODO: pick the latest child

81+ // for now, simply pick the latest child (linear undo / redo)

82+ if let Some((index, transaction)) = current_revision.children.last() {

83+ let success = transaction.apply(state);

76

84

77− // if !success {

85+ if !success {

78− // panic!("Failed to apply undo!");

86+ panic!("Failed to apply redo!");

79− // }

87+ }

80

88

81− unimplemented!()

89+ self.cursor = *index;

90+ }

82 }

91 }

83}

92}

84

93