Show More
@@ -1,264 +1,269 b'' | |||
|
1 | 1 | use crate::utils::hg_path::HgPathBuf; |
|
2 | 2 | use crate::Revision; |
|
3 | 3 | |
|
4 | 4 | use im_rc::ordmap::OrdMap; |
|
5 | 5 | |
|
6 | 6 | use std::collections::HashMap; |
|
7 | 7 | use std::collections::HashSet; |
|
8 | 8 | |
|
9 | 9 | pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>; |
|
10 | 10 | |
|
11 | 11 | #[derive(Clone, Debug)] |
|
12 | 12 | struct TimeStampedPathCopy { |
|
13 | 13 | /// revision at which the copy information was added |
|
14 | 14 | rev: Revision, |
|
15 | 15 | /// the copy source, (Set to None in case of deletion of the associated |
|
16 | 16 | /// key) |
|
17 | 17 | path: Option<HgPathBuf>, |
|
18 | 18 | } |
|
19 | 19 | |
|
20 | 20 | /// maps CopyDestination to Copy Source (+ a "timestamp" for the operation) |
|
21 | 21 | type TimeStampedPathCopies = OrdMap<HgPathBuf, TimeStampedPathCopy>; |
|
22 | 22 | |
|
23 | 23 | /// hold parent 1, parent 2 and relevant files actions. |
|
24 | 24 | pub type RevInfo = (Revision, Revision, ChangedFiles); |
|
25 | 25 | |
|
26 | 26 | /// represent the files affected by a changesets |
|
27 | 27 | /// |
|
28 | 28 | /// This hold a subset of mercurial.metadata.ChangingFiles as we do not need |
|
29 | 29 | /// all the data categories tracked by it. |
|
30 | 30 | pub struct ChangedFiles { |
|
31 | 31 | removed: HashSet<HgPathBuf>, |
|
32 | 32 | merged: HashSet<HgPathBuf>, |
|
33 | 33 | salvaged: HashSet<HgPathBuf>, |
|
34 | 34 | copied_from_p1: PathCopies, |
|
35 | 35 | copied_from_p2: PathCopies, |
|
36 | 36 | } |
|
37 | 37 | |
|
38 | 38 | impl ChangedFiles { |
|
39 | 39 | pub fn new( |
|
40 | 40 | removed: HashSet<HgPathBuf>, |
|
41 | 41 | merged: HashSet<HgPathBuf>, |
|
42 | 42 | salvaged: HashSet<HgPathBuf>, |
|
43 | 43 | copied_from_p1: PathCopies, |
|
44 | 44 | copied_from_p2: PathCopies, |
|
45 | 45 | ) -> Self { |
|
46 | 46 | ChangedFiles { |
|
47 | 47 | removed, |
|
48 | 48 | merged, |
|
49 | 49 | salvaged, |
|
50 | 50 | copied_from_p1, |
|
51 | 51 | copied_from_p2, |
|
52 | 52 | } |
|
53 | 53 | } |
|
54 | 54 | |
|
55 | 55 | pub fn new_empty() -> Self { |
|
56 | 56 | ChangedFiles { |
|
57 | 57 | removed: HashSet::new(), |
|
58 | 58 | merged: HashSet::new(), |
|
59 | 59 | salvaged: HashSet::new(), |
|
60 | 60 | copied_from_p1: PathCopies::new(), |
|
61 | 61 | copied_from_p2: PathCopies::new(), |
|
62 | 62 | } |
|
63 | 63 | } |
|
64 | 64 | } |
|
65 | 65 | |
|
66 | 66 | /// Same as mercurial.copies._combine_changeset_copies, but in Rust. |
|
67 | 67 | /// |
|
68 | 68 | /// Arguments are: |
|
69 | 69 | /// |
|
70 | 70 | /// revs: all revisions to be considered |
|
71 | 71 | /// children: a {parent ? [childrens]} mapping |
|
72 | 72 | /// target_rev: the final revision we are combining copies to |
|
73 | 73 | /// rev_info(rev): callback to get revision information: |
|
74 | 74 | /// * first parent |
|
75 | 75 | /// * second parent |
|
76 | 76 | /// * ChangedFiles |
|
77 | 77 | /// isancestors(low_rev, high_rev): callback to check if a revision is an |
|
78 | 78 | /// ancestor of another |
|
79 | 79 | pub fn combine_changeset_copies( |
|
80 | 80 | revs: Vec<Revision>, |
|
81 | 81 | children: HashMap<Revision, Vec<Revision>>, |
|
82 | 82 | target_rev: Revision, |
|
83 | 83 | rev_info: &impl Fn(Revision) -> RevInfo, |
|
84 | 84 | is_ancestor: &impl Fn(Revision, Revision) -> bool, |
|
85 | 85 | ) -> PathCopies { |
|
86 | 86 | let mut all_copies = HashMap::new(); |
|
87 | 87 | |
|
88 | 88 | for rev in revs { |
|
89 | 89 | // Retrieve data computed in a previous iteration |
|
90 | 90 | let copies = all_copies.remove(&rev); |
|
91 | 91 | let copies = match copies { |
|
92 | 92 | Some(c) => c, |
|
93 | 93 | None => TimeStampedPathCopies::default(), // root of the walked set |
|
94 | 94 | }; |
|
95 | 95 | |
|
96 | 96 | let current_children = match children.get(&rev) { |
|
97 | 97 | Some(c) => c, |
|
98 | 98 | None => panic!("inconsistent `revs` and `children`"), |
|
99 | 99 | }; |
|
100 | 100 | |
|
101 | 101 | for child in current_children { |
|
102 | 102 | // We will chain the copies information accumulated for `rev` with |
|
103 | 103 | // the individual copies information for each of its children. |
|
104 | 104 | // Creating a new PathCopies for each `rev` ? `children` vertex. |
|
105 | 105 | let (p1, p2, changes) = rev_info(*child); |
|
106 | 106 | |
|
107 | 107 | let (parent, child_copies) = if rev == p1 { |
|
108 | 108 | (1, &changes.copied_from_p1) |
|
109 | 109 | } else { |
|
110 | 110 | assert_eq!(rev, p2); |
|
111 | 111 | (2, &changes.copied_from_p2) |
|
112 | 112 | }; |
|
113 | 113 | let mut new_copies = copies.clone(); |
|
114 | 114 | |
|
115 | 115 | for (dest, source) in child_copies { |
|
116 | 116 | let entry; |
|
117 | 117 | if let Some(v) = copies.get(source) { |
|
118 | 118 | entry = match &v.path { |
|
119 | 119 | Some(path) => Some((*(path)).to_owned()), |
|
120 | 120 | None => Some(source.to_owned()), |
|
121 | 121 | } |
|
122 | 122 | } else { |
|
123 | 123 | entry = Some(source.to_owned()); |
|
124 | 124 | } |
|
125 | 125 | // Each new entry is introduced by the children, we record this |
|
126 | 126 | // information as we will need it to take the right decision |
|
127 | 127 | // when merging conflicting copy information. See |
|
128 | 128 | // merge_copies_dict for details. |
|
129 | 129 | let ttpc = TimeStampedPathCopy { |
|
130 | 130 | rev: *child, |
|
131 | 131 | path: entry, |
|
132 | 132 | }; |
|
133 | 133 | new_copies.insert(dest.to_owned(), ttpc); |
|
134 | 134 | } |
|
135 | 135 | |
|
136 | 136 | // We must drop copy information for removed file. |
|
137 | 137 | // |
|
138 | 138 | // We need to explicitly record them as dropped to propagate this |
|
139 | 139 | // information when merging two TimeStampedPathCopies object. |
|
140 | 140 | for f in changes.removed.iter() { |
|
141 | 141 | if new_copies.contains_key(f.as_ref()) { |
|
142 | 142 | let ttpc = TimeStampedPathCopy { |
|
143 | 143 | rev: *child, |
|
144 | 144 | path: None, |
|
145 | 145 | }; |
|
146 | 146 | new_copies.insert(f.to_owned(), ttpc); |
|
147 | 147 | } |
|
148 | 148 | } |
|
149 | 149 | |
|
150 | 150 | // Merge has two parents needs to combines their copy information. |
|
151 | 151 | // |
|
152 | 152 | // If the vertex from the other parent was already processed, we |
|
153 | 153 | // will have a value for the child ready to be used. We need to |
|
154 | 154 | // grab it and combine it with the one we already |
|
155 | 155 | // computed. If not we can simply store the newly |
|
156 | 156 | // computed data. The processing happening at |
|
157 | 157 | // the time of the second parent will take care of combining the |
|
158 | 158 | // two TimeStampedPathCopies instance. |
|
159 | 159 | match all_copies.remove(child) { |
|
160 | 160 | None => { |
|
161 | 161 | all_copies.insert(child, new_copies); |
|
162 | 162 | } |
|
163 | 163 | Some(other_copies) => { |
|
164 | 164 | let (minor, major) = match parent { |
|
165 | 165 | 1 => (other_copies, new_copies), |
|
166 | 166 | 2 => (new_copies, other_copies), |
|
167 | 167 | _ => unreachable!(), |
|
168 | 168 | }; |
|
169 | 169 | let merged_copies = |
|
170 | 170 | merge_copies_dict(minor, major, &changes, is_ancestor); |
|
171 | 171 | all_copies.insert(child, merged_copies); |
|
172 | 172 | } |
|
173 | 173 | }; |
|
174 | 174 | } |
|
175 | 175 | } |
|
176 | 176 | |
|
177 | 177 | // Drop internal information (like the timestamp) and return the final |
|
178 | 178 | // mapping. |
|
179 | 179 | let tt_result = all_copies |
|
180 | 180 | .remove(&target_rev) |
|
181 | 181 | .expect("target revision was not processed"); |
|
182 | 182 | let mut result = PathCopies::default(); |
|
183 | 183 | for (dest, tt_source) in tt_result { |
|
184 | 184 | if let Some(path) = tt_source.path { |
|
185 | 185 | result.insert(dest, path); |
|
186 | 186 | } |
|
187 | 187 | } |
|
188 | 188 | result |
|
189 | 189 | } |
|
190 | 190 | |
|
191 | 191 | /// merge two copies-mapping together, minor and major |
|
192 | 192 | /// |
|
193 | 193 | /// In case of conflict, value from "major" will be picked, unless in some |
|
194 | 194 | /// cases. See inline documentation for details. |
|
195 | 195 | #[allow(clippy::if_same_then_else)] |
|
196 | 196 | fn merge_copies_dict( |
|
197 | 197 | minor: TimeStampedPathCopies, |
|
198 | 198 | major: TimeStampedPathCopies, |
|
199 | 199 | changes: &ChangedFiles, |
|
200 | 200 | is_ancestor: &impl Fn(Revision, Revision) -> bool, |
|
201 | 201 | ) -> TimeStampedPathCopies { |
|
202 | 202 | let mut result = minor.clone(); |
|
203 | 203 | for (dest, src_major) in major { |
|
204 | 204 | let overwrite; |
|
205 | 205 | if let Some(src_minor) = minor.get(&dest) { |
|
206 | if src_major.path == src_minor.path { | |
|
207 | // we have the same value, but from other source; | |
|
208 | if src_major.rev == src_minor.rev { | |
|
209 | // If the two entry are identical, no need to do anything | |
|
206 | { | |
|
207 | if src_major.path == src_minor.path { | |
|
208 | // we have the same value, no need to battle; | |
|
209 | if src_major.rev == src_minor.rev { | |
|
210 | // If the two entry are identical, no need to do | |
|
211 | // anything | |
|
212 | overwrite = false; | |
|
213 | } else if is_ancestor(src_major.rev, src_minor.rev) { | |
|
214 | overwrite = false; | |
|
215 | } else { | |
|
216 | overwrite = true; | |
|
217 | } | |
|
218 | } else if src_major.rev == src_minor.rev { | |
|
219 | // We cannot get copy information for both p1 and p2 in the | |
|
220 | // same rev. So this is the same value. | |
|
221 | overwrite = false; | |
|
222 | } else if src_major.path.is_none() | |
|
223 | && changes.salvaged.contains(&dest) | |
|
224 | { | |
|
225 | // If the file is "deleted" in the major side but was | |
|
226 | // salvaged by the merge, we keep the minor side alive | |
|
210 | 227 | overwrite = false; |
|
228 | } else if src_minor.path.is_none() | |
|
229 | && changes.salvaged.contains(&dest) | |
|
230 | { | |
|
231 | // If the file is "deleted" in the minor side but was | |
|
232 | // salvaged by the merge, unconditionnaly preserve the | |
|
233 | // major side. | |
|
234 | overwrite = true; | |
|
235 | } else if changes.merged.contains(&dest) { | |
|
236 | // If the file was actively merged, copy information from | |
|
237 | // each side might conflict. The major side will win such | |
|
238 | // conflict. | |
|
239 | overwrite = true; | |
|
211 | 240 | } else if is_ancestor(src_major.rev, src_minor.rev) { |
|
241 | // If the minor side is strictly newer than the major side, | |
|
242 | // it should be kept. | |
|
212 | 243 | overwrite = false; |
|
244 | } else if src_major.path.is_some() { | |
|
245 | // without any special case, the "major" value win other | |
|
246 | // the "minor" one. | |
|
247 | overwrite = true; | |
|
248 | } else if is_ancestor(src_minor.rev, src_major.rev) { | |
|
249 | // the "major" rev is a direct ancestors of "minor", any | |
|
250 | // different value should overwrite | |
|
251 | overwrite = true; | |
|
213 | 252 | } else { |
|
214 | overwrite = true; | |
|
253 | // major version is None (so the file was deleted on that | |
|
254 | // branch) and that branch is independant (neither minor | |
|
255 | // nor major is an ancestors of the other one.) We preserve | |
|
256 | // the new information about the new file. | |
|
257 | overwrite = false; | |
|
215 | 258 | } |
|
216 | } else if src_major.rev == src_minor.rev { | |
|
217 | // We cannot get copy information for both p1 and p2 in the | |
|
218 | // same rev. So this is the same value. | |
|
219 | overwrite = false; | |
|
220 | } else if src_major.path.is_none() | |
|
221 | && changes.salvaged.contains(&dest) | |
|
222 | { | |
|
223 | // If the file is "deleted" in the major side but was salvaged | |
|
224 | // by the merge, we keep the minor side alive | |
|
225 | overwrite = false; | |
|
226 | } else if src_minor.path.is_none() | |
|
227 | && changes.salvaged.contains(&dest) | |
|
228 | { | |
|
229 | // If the file is "deleted" in the minor side but was salvaged | |
|
230 | // by the merge, unconditionnaly preserve the major side. | |
|
231 | overwrite = true; | |
|
232 | } else if changes.merged.contains(&dest) { | |
|
233 | // If the file was actively merged, copy information from each | |
|
234 | // side might conflict. The major side will win such conflict. | |
|
235 | overwrite = true; | |
|
236 | } else if is_ancestor(src_major.rev, src_minor.rev) { | |
|
237 | // If the minor side is strictly newer than the major side, it | |
|
238 | // should be kept. | |
|
239 | overwrite = false; | |
|
240 | } else if src_major.path.is_some() { | |
|
241 | // without any special case, the "major" value win other the | |
|
242 | // "minor" one. | |
|
243 | overwrite = true; | |
|
244 | } else if is_ancestor(src_minor.rev, src_major.rev) { | |
|
245 | // the "major" rev is a direct ancestors of "minor", any | |
|
246 | // different value should overwrite | |
|
247 | overwrite = true; | |
|
248 | } else { | |
|
249 | // major version is None (so the file was deleted on that | |
|
250 | // branch) annd that branch is independant (neither minor nor | |
|
251 | // major is an ancestors of the other one.) We preserve the new | |
|
252 | // information about the new file. | |
|
253 | overwrite = false; | |
|
254 | 259 | } |
|
255 | 260 | } else { |
|
256 | 261 | // minor had no value |
|
257 | 262 | overwrite = true; |
|
258 | 263 | } |
|
259 | 264 | if overwrite { |
|
260 | 265 | result.insert(dest, src_major); |
|
261 | 266 | } |
|
262 | 267 | } |
|
263 | 268 | result |
|
264 | 269 | } |
General Comments 0
You need to be logged in to leave comments.
Login now