upstream/mercurial-mirror Files · mercurial/pure/bdiff.py

subrepos: prompt on conflicts on update with dirty subrepos...

subrepos: prompt on conflicts on update with dirty subrepos Consider a repository with a single subrepository. The changesets in the main repository reference the subrepository changesets like this: m0 -> s0 m1 -> s1 m2 -> s2 Starting from a state (m1, s0), doing 'hg update m2' in the main repository will yield a conflict: the subrepo is at revision s0 but the target revision says it should be at revision s2. Before this change, Mercurial would do (m1, s0) -> (m2, s2) and thus ignore the conflict between the working copy and the target revision. With this change, the user is prompted to resolve the conflict by choosing which revision he wants. This is consistent with 'hg merge', which also prompts the user when it detects conflicts in the merged .hgsubstate files. The prompt looks like this: $ hg update tip subrepository sources for my-subrepo differ use (l)ocal source (fc627a69481f) or (r)emote source (12a213df6fa9)?

Matt Mackall - - Load All Authors

File last commit:

r10282:08a0f04b default


                r13417:0748e18b

default

Download file

             bdiff.py
        
                    78 lines
            
             | 2.0 KiB
            
                | text/x-python
            
             |
                PythonLexer
            
             / mercurial / pure / bdiff.py
          
                    History
                
                 |
                  Annotation
                 | Raw
                 |Copy content
                 |Copy permalink

      # bdiff.py - Python implementation of bdiff.c

      #

      # Copyright 2009 Matt Mackall <mpm@selenic.com> and others

      #

      # This software may be used and distributed according to the terms of the

      # GNU General Public License version 2 or any later version.

      import struct, difflib

      def splitnewlines(text):

          '''like str.splitlines, but only split on newlines.'''

          lines = [l + '\n' for l in text.split('\n')]

          if lines:

              if lines[-1] == '\n':

                  lines.pop()

              else:

                  lines[-1] = lines[-1][:-1]

          return lines

      def _normalizeblocks(a, b, blocks):

          prev = None

          for curr in blocks:

              if prev is None:

                  prev = curr

                  continue

              shift = 0

              a1, b1, l1 = prev

              a1end = a1 + l1

              b1end = b1 + l1

              a2, b2, l2 = curr

              a2end = a2 + l2

              b2end = b2 + l2

              if a1end == a2:

                  while (a1end + shift < a2end and

                         a[a1end + shift] == b[b1end + shift]):

                      shift += 1

              elif b1end == b2:

                  while (b1end + shift < b2end and

                         a[a1end + shift] == b[b1end + shift]):

                      shift += 1

              yield a1, b1, l1 + shift

              prev = a2 + shift, b2 + shift, l2 - shift

          yield prev

      def bdiff(a, b):

          a = str(a).splitlines(True)

          b = str(b).splitlines(True)

          if not a:

              s = "".join(b)

              return s and (struct.pack(">lll", 0, 0, len(s)) + s)

          bin = []

          p = [0]

          for i in a: p.append(p[-1] + len(i))

          d = difflib.SequenceMatcher(None, a, b).get_matching_blocks()

          d = _normalizeblocks(a, b, d)

          la = 0

          lb = 0

          for am, bm, size in d:

              s = "".join(b[lb:bm])

              if am > la or s:

                  bin.append(struct.pack(">lll", p[la], p[am], len(s)) + s)

              la = am + size

              lb = bm + size

          return "".join(bin)

      def blocks(a, b):

          an = splitnewlines(a)

          bn = splitnewlines(b)

          d = difflib.SequenceMatcher(None, an, bn).get_matching_blocks()

          d = _normalizeblocks(an, bn, d)

          return [(i, i + n, j, j + n) for (i, j, n) in d]

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

				# bdiff.py - Python implementation of bdiff.c
				#
				# Copyright 2009 Matt Mackall <mpm@selenic.com> and others
				#
				# This software may be used and distributed according to the terms of the
				# GNU General Public License version 2 or any later version.

				import struct, difflib

				def splitnewlines(text):
				'''like str.splitlines, but only split on newlines.'''
				lines = [l + '\n' for l in text.split('\n')]
				if lines:
				if lines[-1] == '\n':
				lines.pop()
				else:
				lines[-1] = lines[-1][:-1]
				return lines

				def _normalizeblocks(a, b, blocks):
				prev = None
				for curr in blocks:
				if prev is None:
				prev = curr
				continue
				shift = 0

				a1, b1, l1 = prev
				a1end = a1 + l1
				b1end = b1 + l1

				a2, b2, l2 = curr
				a2end = a2 + l2
				b2end = b2 + l2
				if a1end == a2:
				while (a1end + shift < a2end and
				a[a1end + shift] == b[b1end + shift]):
				shift += 1
				elif b1end == b2:
				while (b1end + shift < b2end and
				a[a1end + shift] == b[b1end + shift]):
				shift += 1
				yield a1, b1, l1 + shift
				prev = a2 + shift, b2 + shift, l2 - shift
				yield prev

				def bdiff(a, b):
				a = str(a).splitlines(True)
				b = str(b).splitlines(True)

				if not a:
				s = "".join(b)
				return s and (struct.pack(">lll", 0, 0, len(s)) + s)

				bin = []
				p = [0]
				for i in a: p.append(p[-1] + len(i))

				d = difflib.SequenceMatcher(None, a, b).get_matching_blocks()
				d = _normalizeblocks(a, b, d)
				la = 0
				lb = 0
				for am, bm, size in d:
				s = "".join(b[lb:bm])
				if am > la or s:
				bin.append(struct.pack(">lll", p[la], p[am], len(s)) + s)
				la = am + size
				lb = bm + size

				return "".join(bin)

				def blocks(a, b):
				an = splitnewlines(a)
				bn = splitnewlines(b)
				d = difflib.SequenceMatcher(None, an, bn).get_matching_blocks()
				d = _normalizeblocks(an, bn, d)
				return [(i, i + n, j, j + n) for (i, j, n) in d]