merge_groups() currently yields 2-tuples or 4-tuples, making the
callers check the first element to decide how to interpret the
rest. Let's make it yield only 2-tuples, thereby simplifying life a
little for the callers.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/simplemerge.py (26 lines) | |||
| M | tests/test-simplemerge.py (2 lines) |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz |
| Lines taken from a | Lines taken from a | ||||
| 'same', lines | 'same', lines | ||||
| Lines taken from a (and equal to b) | Lines taken from a (and equal to b) | ||||
| 'b', lines | 'b', lines | ||||
| Lines taken from b | Lines taken from b | ||||
| 'conflict', base_lines, a_lines, b_lines | 'conflict', (base_lines, a_lines, b_lines) | ||||
| Lines from base were changed to either a or b and conflict. | Lines from base were changed to either a or b and conflict. | ||||
| """ | """ | ||||
| for t in self.merge_regions(): | for t in self.merge_regions(): | ||||
| what = t[0] | what = t[0] | ||||
| if what == b'unchanged': | if what == b'unchanged': | ||||
| yield what, self.base[t[1] : t[2]] | yield what, self.base[t[1] : t[2]] | ||||
| elif what == b'a' or what == b'same': | elif what == b'a' or what == b'same': | ||||
| yield what, self.a[t[1] : t[2]] | yield what, self.a[t[1] : t[2]] | ||||
| elif what == b'b': | elif what == b'b': | ||||
| yield what, self.b[t[1] : t[2]] | yield what, self.b[t[1] : t[2]] | ||||
| elif what == b'conflict': | elif what == b'conflict': | ||||
| yield ( | yield ( | ||||
| what, | what, | ||||
| ( | |||||
| self.base[t[1] : t[2]], | self.base[t[1] : t[2]], | ||||
| self.a[t[3] : t[4]], | self.a[t[3] : t[4]], | ||||
| self.b[t[5] : t[6]], | self.b[t[5] : t[6]], | ||||
| ), | |||||
| ) | ) | ||||
| else: | else: | ||||
| raise ValueError(what) | raise ValueError(what) | ||||
| def merge_regions(self): | def merge_regions(self): | ||||
| """Return sequences of matching and conflicting regions. | """Return sequences of matching and conflicting regions. | ||||
| This returns tuples, where the first value says what kind we | This returns tuples, where the first value says what kind we | ||||
| for i, override in enumerate(overrides): | for i, override in enumerate(overrides): | ||||
| result[i] = override | result[i] = override | ||||
| return result | return result | ||||
| def _mergediff(m3, name_a, name_b, name_base): | def _mergediff(m3, name_a, name_b, name_base): | ||||
| lines = [] | lines = [] | ||||
| conflicts = False | conflicts = False | ||||
| for group in m3.merge_groups(): | for what, group_lines in m3.merge_groups(): | ||||
| if group[0] == b'conflict': | if what == b'conflict': | ||||
| base_lines, a_lines, b_lines = group[1:] | base_lines, a_lines, b_lines = group_lines | ||||
| base_text = b''.join(base_lines) | base_text = b''.join(base_lines) | ||||
| b_blocks = list( | b_blocks = list( | ||||
| mdiff.allblocks( | mdiff.allblocks( | ||||
| base_text, | base_text, | ||||
| b''.join(b_lines), | b''.join(b_lines), | ||||
| lines1=base_lines, | lines1=base_lines, | ||||
| lines2=b_lines, | lines2=b_lines, | ||||
| ) | ) | ||||
| lines.append(b"------- %s\n" % name_base) | lines.append(b"------- %s\n" % name_base) | ||||
| lines.append(b"+++++++ %s\n" % name_a) | lines.append(b"+++++++ %s\n" % name_a) | ||||
| lines.extend(diff_lines(a_blocks, base_lines, a_lines)) | lines.extend(diff_lines(a_blocks, base_lines, a_lines)) | ||||
| lines.append(b"======= %s\n" % name_b) | lines.append(b"======= %s\n" % name_b) | ||||
| lines.extend(b_lines) | lines.extend(b_lines) | ||||
| lines.append(b">>>>>>>\n") | lines.append(b">>>>>>>\n") | ||||
| conflicts = True | conflicts = True | ||||
| else: | else: | ||||
| lines.extend(group[1]) | lines.extend(group_lines) | ||||
| return lines, conflicts | return lines, conflicts | ||||
| def _resolve(m3, sides): | def _resolve(m3, sides): | ||||
| lines = [] | lines = [] | ||||
| for group in m3.merge_groups(): | for what, group_lines in m3.merge_groups(): | ||||
| if group[0] == b'conflict': | if what == b'conflict': | ||||
| for side in sides: | for side in sides: | ||||
| lines.extend(group[side + 1]) | lines.extend(group_lines[side]) | ||||
| else: | else: | ||||
| lines.extend(group[1]) | lines.extend(group_lines) | ||||
| return lines | return lines | ||||
| def simplemerge(ui, localctx, basectx, otherctx, **opts): | def simplemerge(ui, localctx, basectx, otherctx, **opts): | ||||
| """Performs the simplemerge algorithm. | """Performs the simplemerge algorithm. | ||||
| The merged result is written into `localctx`. | The merged result is written into `localctx`. | ||||
| """ | """ | ||||
| (b'unchanged', 1, 2), | (b'unchanged', 1, 2), | ||||
| ], | ], | ||||
| ) | ) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| list(m3.merge_groups()), | list(m3.merge_groups()), | ||||
| [ | [ | ||||
| (b'unchanged', [b'aaa\n']), | (b'unchanged', [b'aaa\n']), | ||||
| (b'conflict', [], [b'111\n'], [b'222\n']), | (b'conflict', ([], [b'111\n'], [b'222\n'])), | ||||
| (b'unchanged', [b'bbb\n']), | (b'unchanged', [b'bbb\n']), | ||||
| ], | ], | ||||
| ) | ) | ||||
| ml = m3.merge_lines( | ml = m3.merge_lines( | ||||
| name_a=b'a', | name_a=b'a', | ||||
| name_b=b'b', | name_b=b'b', | ||||
| start_marker=b'<<', | start_marker=b'<<', | ||||