~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

• browse files at revision 2052.6.2
• compare with another revision
• download diff
• download tarball
• view history from revision 2052.6.2

Show diffs side-by-side

added

removed

bzrlib/diff.py

14

14

# along with this program; if not, write to the Free Software

15

15

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

16

16

 

17

 

import errno

18

17

import os

19

18

import re

 

19

import sys

 

20

 

 

21

from bzrlib.lazy_import import lazy_import

 

22

lazy_import(globals(), """

 

23

import errno

20

24

import subprocess

21

 

import sys

22

25

import tempfile

23

26

import time

24

27

 

25

28

from bzrlib import (

26

29

    errors,

27

30

    osutils,

 

31

    patiencediff,

 

32

    textfile,

 

33

    timestamp,

28

34

    )

 

35

""")

 

36

 

29

37

# compatability - plugins import compare_trees from diff!!!

30

38

# deprecated as of 0.10

31

39

from bzrlib.delta import compare_trees

32

 

from bzrlib.errors import BzrError

33

 

from bzrlib.patiencediff import unified_diff

34

 

import bzrlib.patiencediff

35

 

from bzrlib.symbol_versioning import (deprecated_function,

36

 

        zero_eight)

37

 

from bzrlib.textfile import check_text_lines

 

40

from bzrlib.symbol_versioning import (

 

41

        deprecated_function,

 

42

        zero_eight,

 

43

        )

38

44

from bzrlib.trace import mutter, warning

39

45

 

40

46

 

62

68

        return

63

69

    

64

70

    if allow_binary is False:

65

 

        check_text_lines(oldlines)

66

 

        check_text_lines(newlines)

 

71

        textfile.check_text_lines(oldlines)

 

72

        textfile.check_text_lines(newlines)

67

73

 

68

74

    if sequence_matcher is None:

69

 

        sequence_matcher = bzrlib.patiencediff.PatienceSequenceMatcher

70

 

    ud = unified_diff(oldlines, newlines,

 

75

        sequence_matcher = patiencediff.PatienceSequenceMatcher

 

76

    ud = patiencediff.unified_diff(oldlines, newlines,

71

77

                      fromfile=old_filename.encode(path_encoding),

72

78

                      tofile=new_filename.encode(path_encoding),

73

79

                      sequencematcher=sequence_matcher)

90

96

    print >>to_file

91

97

 

92

98

 

93

 

def _set_lang_C():

94

 

    """Set the env var LANG=C"""

95

 

    osutils.set_or_unset_env('LANG', 'C')

96

 

    osutils.set_or_unset_env('LC_ALL', None)

97

 

    osutils.set_or_unset_env('LC_CTYPE', None)

98

 

    osutils.set_or_unset_env('LANGUAGE', None)

99

 

 

100

 

 

101

99

def _spawn_external_diff(diffcmd, capture_errors=True):

102

100

    """Spawn the externall diff process, and return the child handle.

103

101

 

104

102

    :param diffcmd: The command list to spawn

105

 

    :param capture_errors: Capture stderr as well as setting LANG=C.

106

 

        This lets us read and understand the output of diff, and respond 

107

 

        to any errors.

 

103

    :param capture_errors: Capture stderr as well as setting LANG=C

 

104

        and LC_ALL=C. This lets us read and understand the output of diff,

 

105

        and respond to any errors.

108

106

    :return: A Popen object.

109

107

    """

110

108

    if capture_errors:

111

 

        if sys.platform == 'win32':

112

 

            # Win32 doesn't support preexec_fn, but that is

113

 

            # okay, because it doesn't support LANG either.

114

 

            preexec_fn = None

115

 

        else:

116

 

            preexec_fn = _set_lang_C

 

109

        # construct minimal environment

 

110

        env = {}

 

111

        path = os.environ.get('PATH')

 

112

        if path is not None:

 

113

            env['PATH'] = path

 

114

        env['LANGUAGE'] = 'C'   # on win32 only LANGUAGE has effect

 

115

        env['LANG'] = 'C'

 

116

        env['LC_ALL'] = 'C'

117

117

        stderr = subprocess.PIPE

118

118

    else:

119

 

        preexec_fn = None

 

119

        env = None

120

120

        stderr = None

121

121

 

122

122

    try:

124

124

                                stdin=subprocess.PIPE,

125

125

                                stdout=subprocess.PIPE,

126

126

                                stderr=stderr,

127

 

                                preexec_fn=preexec_fn)

 

127

                                env=env)

128

128

    except OSError, e:

129

129

        if e.errno == errno.ENOENT:

130

130

            raise errors.NoDiff(str(e))

212

212

            # Write out the new i18n diff response

213

213

            to_file.write(out+'\n')

214

214

            if pipe.returncode != 2:

215

 

                raise BzrError('external diff failed with exit code 2'

216

 

                               ' when run with LANG=C, but not when run'

217

 

                               ' natively: %r' % (diffcmd,))

 

215

                raise errors.BzrError(

 

216

                               'external diff failed with exit code 2'

 

217

                               ' when run with LANG=C and LC_ALL=C,'

 

218

                               ' but not when run natively: %r' % (diffcmd,))

218

219

 

219

220

            first_line = lang_c_out.split('\n', 1)[0]

220

221

            # Starting with diffutils 2.8.4 the word "binary" was dropped.

221

222

            m = re.match('^(binary )?files.*differ$', first_line, re.I)

222

223

            if m is None:

223

 

                raise BzrError('external diff failed with exit code 2;'

224

 

                               ' command: %r' % (diffcmd,))

 

224

                raise errors.BzrError('external diff failed with exit code 2;'

 

225

                                      ' command: %r' % (diffcmd,))

225

226

            else:

226

227

                # Binary files differ, just return

227

228

                return

236

237

            else:

237

238

                msg = 'exit code %d' % rc

238

239

                

239

 

            raise BzrError('external diff failed with %s; command: %r' 

240

 

                           % (rc, diffcmd))

 

240

            raise errors.BzrError('external diff failed with %s; command: %r' 

 

241

                                  % (rc, diffcmd))

241

242

 

242

243

 

243

244

    finally:

300

301

 

301

302

def diff_cmd_helper(tree, specific_files, external_diff_options, 

302

303

                    old_revision_spec=None, new_revision_spec=None,

 

304

                    revision_specs=None,

303

305

                    old_label='a/', new_label='b/'):

304

306

    """Helper for cmd_diff.

305

307

 

306

 

   tree 

 

308

    :param tree:

307

309

        A WorkingTree

308

310

 

309

 

    specific_files

 

311

    :param specific_files:

310

312

        The specific files to compare, or None

311

313

 

312

 

    external_diff_options

 

314

    :param external_diff_options:

313

315

        If non-None, run an external diff, and pass it these options

314

316

 

315

 

    old_revision_spec

 

317

    :param old_revision_spec:

316

318

        If None, use basis tree as old revision, otherwise use the tree for

317

319

        the specified revision. 

318

320

 

319

 

    new_revision_spec

 

321

    :param new_revision_spec:

320

322

        If None, use working tree as new revision, otherwise use the tree for

321

323

        the specified revision.

322

324

    

 

325

    :param revision_specs: 

 

326

        Zero, one or two RevisionSpecs from the command line, saying what revisions 

 

327

        to compare.  This can be passed as an alternative to the old_revision_spec 

 

328

        and new_revision_spec parameters.

 

329

 

323

330

    The more general form is show_diff_trees(), where the caller

324

331

    supplies any two trees.

325

332

    """

 

333

 

 

334

    # TODO: perhaps remove the old parameters old_revision_spec and

 

335

    # new_revision_spec, since this is only really for use from cmd_diff and

 

336

    # it now always passes through a sequence of revision_specs -- mbp

 

337

    # 20061221

 

338

 

326

339

    def spec_tree(spec):

327

340

        if tree:

328

341

            revision = spec.in_store(tree.branch)

331

344

        revision_id = revision.rev_id

332

345

        branch = revision.branch

333

346

        return branch.repository.revision_tree(revision_id)

 

347

 

 

348

    if revision_specs is not None:

 

349

        assert (old_revision_spec is None

 

350

                and new_revision_spec is None)

 

351

        if len(revision_specs) > 0:

 

352

            old_revision_spec = revision_specs[0]

 

353

        if len(revision_specs) > 1:

 

354

            new_revision_spec = revision_specs[1]

 

355

 

334

356

    if old_revision_spec is None:

335

357

        old_tree = tree.basis_tree()

336

358

    else:

337

359

        old_tree = spec_tree(old_revision_spec)

338

360

 

339

 

    if new_revision_spec is None:

 

361

    if (new_revision_spec is None

 

362

        or new_revision_spec.spec is None):

340

363

        new_tree = tree

341

364

    else:

342

365

        new_tree = spec_tree(new_revision_spec)

 

366

 

343

367

    if new_tree is not tree:

344

368

        extra_trees = (tree,)

345

369

    else:

368

392

    """

369

393

    old_tree.lock_read()

370

394

    try:

 

395

        if extra_trees is not None:

 

396

            for tree in extra_trees:

 

397

                tree.lock_read()

371

398

        new_tree.lock_read()

372

399

        try:

373

400

            return _show_diff_trees(old_tree, new_tree, to_file,

376

403

                                    extra_trees=extra_trees)

377

404

        finally:

378

405

            new_tree.unlock()

 

406

            if extra_trees is not None:

 

407

                for tree in extra_trees:

 

408

                    tree.unlock()

379

409

    finally:

380

410

        old_tree.unlock()

381

411

 

441

471

        has_changes = 1

442

472

        prop_str = get_prop_change(meta_modified)

443

473

        print >>to_file, '=== modified %s %r%s' % (kind, path.encode('utf8'), prop_str)

444

 

        old_name = '%s%s\t%s' % (old_label, path,

445

 

                                 _patch_header_date(old_tree, file_id, path))

 

474

        # The file may be in a different location in the old tree (because

 

475

        # the containing dir was renamed, but the file itself was not)

 

476

        old_path = old_tree.id2path(file_id)

 

477

        old_name = '%s%s\t%s' % (old_label, old_path,

 

478

                                 _patch_header_date(old_tree, file_id, old_path))

446

479

        new_name = '%s%s\t%s' % (new_label, path,

447

480

                                 _patch_header_date(new_tree, file_id, path))

448

481

        if text_modified:

455

488

 

456

489

def _patch_header_date(tree, file_id, path):

457

490

    """Returns a timestamp suitable for use in a patch header."""

458

 

    tm = time.gmtime(tree.get_file_mtime(file_id, path))

459

 

    return time.strftime('%Y-%m-%d %H:%M:%S +0000', tm)

 

491

    mtime = tree.get_file_mtime(file_id, path)

 

492

    assert mtime is not None, \

 

493

        "got an mtime of None for file-id %s, path %s in tree %s" % (

 

494

                file_id, path, tree)

 

495

    return timestamp.format_patch_date(mtime)

460

496

 

461

497

 

462

498

def _raise_if_nonexistent(paths, old_tree, new_tree):

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1