~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

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

• reverse the comparison (1910.2.1 to 1185.16.85)
• stop comparing with revision 1185.16.85

Show diffs side-by-side

added

removed

bzrlib/diff.py

1

 

# -*- coding: UTF-8 -*-

2

 

 

 

1

# Copyright (C) 2004, 2005, 2006 Canonical Ltd.

 

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

5

5

# the Free Software Foundation; either version 2 of the License, or

6

6

# (at your option) any later version.

7

 

 

 

7

#

8

8

# This program is distributed in the hope that it will be useful,

9

9

# but WITHOUT ANY WARRANTY; without even the implied warranty of

10

10

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

11

11

# GNU General Public License for more details.

12

 

 

 

12

#

13

13

# You should have received a copy of the GNU General Public License

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

 

from bzrlib.trace import mutter

 

17

import errno

 

18

import os

 

19

import re

 

20

import subprocess

 

21

import sys

 

22

import tempfile

 

23

import time

 

24

 

 

25

# compatability - plugins import compare_trees from diff!!!

 

26

# deprecated as of 0.10

 

27

from bzrlib.delta import compare_trees

18

28

from bzrlib.errors import BzrError

19

 

from bzrlib.delta import compare_trees

 

29

import bzrlib.errors as errors

 

30

import bzrlib.osutils

 

31

from bzrlib.patiencediff import unified_diff

 

32

import bzrlib.patiencediff

 

33

from bzrlib.symbol_versioning import (deprecated_function,

 

34

        zero_eight)

 

35

from bzrlib.textfile import check_text_lines

 

36

from bzrlib.trace import mutter, warning

 

37

 

20

38

 

21

39

# TODO: Rather than building a changeset object, we should probably

22

40

# invoke callbacks on an object.  That object can either accumulate a

23

41

# list, write them out directly, etc etc.

24

42

 

25

 

def internal_diff(old_label, oldlines, new_label, newlines, to_file):

26

 

    import difflib

27

 

    

 

43

def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,

 

44

                  allow_binary=False, sequence_matcher=None,

 

45

                  path_encoding='utf8'):

28

46

    # FIXME: difflib is wrong if there is no trailing newline.

29

47

    # The syntax used by patch seems to be "\ No newline at

30

48

    # end of file" following the last diff line from that

40

58

    # both sequences are empty.

41

59

    if not oldlines and not newlines:

42

60

        return

 

61

    

 

62

    if allow_binary is False:

 

63

        check_text_lines(oldlines)

 

64

        check_text_lines(newlines)

43

65

 

44

 

    ud = difflib.unified_diff(oldlines, newlines,

45

 

                              fromfile=old_label, tofile=new_label)

 

66

    if sequence_matcher is None:

 

67

        sequence_matcher = bzrlib.patiencediff.PatienceSequenceMatcher

 

68

    ud = unified_diff(oldlines, newlines,

 

69

                      fromfile=old_filename.encode(path_encoding),

 

70

                      tofile=new_filename.encode(path_encoding),

 

71

                      sequencematcher=sequence_matcher)

46

72

 

47

73

    ud = list(ud)

48

74

    # work-around for difflib being too smart for its own good

62

88

    print >>to_file

63

89

 

64

90

 

65

 

def external_diff(old_label, oldlines, new_label, newlines, to_file,

 

91

def external_diff(old_filename, oldlines, new_filename, newlines, to_file,

66

92

                  diff_opts):

67

93

    """Display a diff by calling out to the external diff program."""

68

 

    import sys

69

 

    

70

 

    if to_file != sys.stdout:

71

 

        raise NotImplementedError("sorry, can't send external diff other than to stdout yet",

72

 

                                  to_file)

73

 

 

74

94

    # make sure our own output is properly ordered before the diff

75

95

    to_file.flush()

76

96

 

77

 

    from tempfile import NamedTemporaryFile

78

 

    import os

79

 

 

80

 

    oldtmpf = NamedTemporaryFile()

81

 

    newtmpf = NamedTemporaryFile()

 

97

    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')

 

98

    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')

 

99

    oldtmpf = os.fdopen(oldtmp_fd, 'wb')

 

100

    newtmpf = os.fdopen(newtmp_fd, 'wb')

82

101

 

83

102

    try:

84

103

        # TODO: perhaps a special case for comparing to or from the empty

91

110

        oldtmpf.writelines(oldlines)

92

111

        newtmpf.writelines(newlines)

93

112

 

94

 

        oldtmpf.flush()

95

 

        newtmpf.flush()

 

113

        oldtmpf.close()

 

114

        newtmpf.close()

96

115

 

97

116

        if not diff_opts:

98

117

            diff_opts = []

99

118

        diffcmd = ['diff',

100

 

                   '--label', old_label,

101

 

                   oldtmpf.name,

102

 

                   '--label', new_label,

103

 

                   newtmpf.name]

 

119

                   '--label', old_filename,

 

120

                   old_abspath,

 

121

                   '--label', new_filename,

 

122

                   new_abspath,

 

123

                   '--binary',

 

124

                  ]

104

125

 

105

126

        # diff only allows one style to be specified; they don't override.

106

127

        # note that some of these take optargs, and the optargs can be

126

147

        if diff_opts:

127

148

            diffcmd.extend(diff_opts)

128

149

 

129

 

        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)

 

150

        try:

 

151

            pipe = subprocess.Popen(diffcmd,

 

152

                                    stdin=subprocess.PIPE,

 

153

                                    stdout=subprocess.PIPE)

 

154

        except OSError, e:

 

155

            if e.errno == errno.ENOENT:

 

156

                raise errors.NoDiff(str(e))

 

157

            raise

 

158

        pipe.stdin.close()

 

159

 

 

160

        first_line = pipe.stdout.readline()

 

161

        to_file.write(first_line)

 

162

        bzrlib.osutils.pumpfile(pipe.stdout, to_file)

 

163

        rc = pipe.wait()

130

164

        

131

 

        if rc != 0 and rc != 1:

 

165

        if rc == 2:

 

166

            # 'diff' gives retcode == 2 for all sorts of errors

 

167

            # one of those is 'Binary files differ'.

 

168

            # Bad options could also be the problem.

 

169

            # 'Binary files' is not a real error, so we suppress that error

 

170

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

 

171

            if not m:

 

172

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

 

173

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

 

174

        elif rc not in (0, 1):

132

175

            # returns 1 if files differ; that's OK

133

176

            if rc < 0:

134

177

                msg = 'signal %d' % (-rc)

135

178

            else:

136

179

                msg = 'exit code %d' % rc

137

180

                

138

 

            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))

 

181

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

 

182

                           % (rc, diffcmd))

 

183

 

 

184

        # internal_diff() adds a trailing newline, add one here for consistency

 

185

        to_file.write('\n')

 

186

 

139

187

    finally:

140

188

        oldtmpf.close()                 # and delete

141

189

        newtmpf.close()

142

 

 

 

190

        # Clean up. Warn in case the files couldn't be deleted

 

191

        # (in case windows still holds the file open, but not

 

192

        # if the files have already been deleted)

 

193

        try:

 

194

            os.remove(old_abspath)

 

195

        except OSError, e:

 

196

            if e.errno not in (errno.ENOENT,):

 

197

                warning('Failed to delete temporary file: %s %s',

 

198

                        old_abspath, e)

 

199

        try:

 

200

            os.remove(new_abspath)

 

201

        except OSError:

 

202

            if e.errno not in (errno.ENOENT,):

 

203

                warning('Failed to delete temporary file: %s %s',

 

204

                        new_abspath, e)

 

205

 

 

206

 

 

207

@deprecated_function(zero_eight)

143

208

def show_diff(b, from_spec, specific_files, external_diff_options=None,

144

 

              revision2=None, output=None):

 

209

              revision2=None, output=None, b2=None):

145

210

    """Shortcut for showing the diff to the working tree.

146

211

 

 

212

    Please use show_diff_trees instead.

 

213

 

147

214

    b

148

215

        Branch.

149

216

 

154

221

    supplies any two trees.

155

222

    """

156

223

    if output is None:

157

 

        import sys

158

224

        output = sys.stdout

159

225

 

160

226

    if from_spec is None:

161

 

        old_tree = b.basis_tree()

 

227

        old_tree = b.bzrdir.open_workingtree()

 

228

        if b2 is None:

 

229

            old_tree = old_tree = old_tree.basis_tree()

162

230

    else:

163

 

        old_tree = b.revision_tree(from_spec.in_history(b).rev_id)

 

231

        old_tree = b.repository.revision_tree(from_spec.in_history(b).rev_id)

164

232

 

165

233

    if revision2 is None:

166

 

        new_tree = b.working_tree()

167

 

    else:

168

 

        new_tree = b.revision_tree(revision2.in_history(b).rev_id)

169

 

 

170

 

    show_diff_trees(old_tree, new_tree, output, specific_files,

171

 

                    external_diff_options)

172

 

 

 

234

        if b2 is None:

 

235

            new_tree = b.bzrdir.open_workingtree()

 

236

        else:

 

237

            new_tree = b2.bzrdir.open_workingtree()

 

238

    else:

 

239

        new_tree = b.repository.revision_tree(revision2.in_history(b).rev_id)

 

240

 

 

241

    return show_diff_trees(old_tree, new_tree, output, specific_files,

 

242

                           external_diff_options)

 

243

 

 

244

 

 

245

def diff_cmd_helper(tree, specific_files, external_diff_options, 

 

246

                    old_revision_spec=None, new_revision_spec=None,

 

247

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

 

248

    """Helper for cmd_diff.

 

249

 

 

250

   tree 

 

251

        A WorkingTree

 

252

 

 

253

    specific_files

 

254

        The specific files to compare, or None

 

255

 

 

256

    external_diff_options

 

257

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

 

258

 

 

259

    old_revision_spec

 

260

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

 

261

        the specified revision. 

 

262

 

 

263

    new_revision_spec

 

264

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

 

265

        the specified revision.

 

266

    

 

267

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

 

268

    supplies any two trees.

 

269

    """

 

270

    def spec_tree(spec):

 

271

        if tree:

 

272

            revision = spec.in_store(tree.branch)

 

273

        else:

 

274

            revision = spec.in_store(None)

 

275

        revision_id = revision.rev_id

 

276

        branch = revision.branch

 

277

        return branch.repository.revision_tree(revision_id)

 

278

    if old_revision_spec is None:

 

279

        old_tree = tree.basis_tree()

 

280

    else:

 

281

        old_tree = spec_tree(old_revision_spec)

 

282

 

 

283

    if new_revision_spec is None:

 

284

        new_tree = tree

 

285

    else:

 

286

        new_tree = spec_tree(new_revision_spec)

 

287

    if new_tree is not tree:

 

288

        extra_trees = (tree,)

 

289

    else:

 

290

        extra_trees = None

 

291

 

 

292

    return show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,

 

293

                           external_diff_options,

 

294

                           old_label=old_label, new_label=new_label,

 

295

                           extra_trees=extra_trees)

173

296

 

174

297

 

175

298

def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,

176

 

                    external_diff_options=None):

 

299

                    external_diff_options=None,

 

300

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

 

301

                    extra_trees=None):

177

302

    """Show in text form the changes from one tree to another.

178

303

 

179

304

    to_files

181

306

 

182

307

    external_diff_options

183

308

        If set, use an external GNU diff and pass these options.

 

309

 

 

310

    extra_trees

 

311

        If set, more Trees to use for looking up file ids

184

312

    """

185

 

 

186

 

    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string

187

 

    old_label = ''

188

 

    new_label = ''

189

 

 

190

 

    DEVNULL = '/dev/null'

191

 

    # Windows users, don't panic about this filename -- it is a

192

 

    # special signal to GNU patch that the file should be created or

193

 

    # deleted respectively.

 

313

    old_tree.lock_read()

 

314

    try:

 

315

        new_tree.lock_read()

 

316

        try:

 

317

            return _show_diff_trees(old_tree, new_tree, to_file,

 

318

                                    specific_files, external_diff_options,

 

319

                                    old_label=old_label, new_label=new_label,

 

320

                                    extra_trees=extra_trees)

 

321

        finally:

 

322

            new_tree.unlock()

 

323

    finally:

 

324

        old_tree.unlock()

 

325

 

 

326

 

 

327

def _show_diff_trees(old_tree, new_tree, to_file,

 

328

                     specific_files, external_diff_options, 

 

329

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

 

330

 

 

331

    # GNU Patch uses the epoch date to detect files that are being added

 

332

    # or removed in a diff.

 

333

    EPOCH_DATE = '1970-01-01 00:00:00 +0000'

194

334

 

195

335

    # TODO: Generation of pseudo-diffs for added/deleted files could

196

336

    # be usefully made into a much faster special case.

203

343

    else:

204

344

        diff_file = internal_diff

205

345

    

206

 

 

207

 

    delta = compare_trees(old_tree, new_tree, want_unchanged=False,

208

 

                          specific_files=specific_files)

209

 

 

 

346

    delta = new_tree.changes_from(old_tree,

 

347

        specific_files=specific_files,

 

348

        extra_trees=extra_trees, require_versioned=True)

 

349

 

 

350

    has_changes = 0

210

351

    for path, file_id, kind in delta.removed:

211

 

        print >>to_file, '=== removed %s %r' % (kind, path)

212

 

        old_tree.inventory[file_id].diff(diff_file, old_label + path, old_tree,

213

 

                                         DEVNULL, None, None, to_file)

 

352

        has_changes = 1

 

353

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

 

354

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

 

355

                                 _patch_header_date(old_tree, file_id, path))

 

356

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

 

357

        old_tree.inventory[file_id].diff(diff_file, old_name, old_tree,

 

358

                                         new_name, None, None, to_file)

214

359

    for path, file_id, kind in delta.added:

215

 

        print >>to_file, '=== added %s %r' % (kind, path)

216

 

        new_tree.inventory[file_id].diff(diff_file, new_label + path, new_tree,

217

 

                                         DEVNULL, None, None, to_file, 

 

360

        has_changes = 1

 

361

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

 

362

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

 

363

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

 

364

                                 _patch_header_date(new_tree, file_id, path))

 

365

        new_tree.inventory[file_id].diff(diff_file, new_name, new_tree,

 

366

                                         old_name, None, None, to_file, 

218

367

                                         reverse=True)

219

368

    for (old_path, new_path, file_id, kind,

220

369

         text_modified, meta_modified) in delta.renamed:

 

370

        has_changes = 1

221

371

        prop_str = get_prop_change(meta_modified)

222

372

        print >>to_file, '=== renamed %s %r => %r%s' % (

223

 

                          kind, old_path, new_path, prop_str)

224

 

        _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,

225

 

                                    new_label, new_path, new_tree,

 

373

                    kind, old_path.encode('utf8'),

 

374

                    new_path.encode('utf8'), prop_str)

 

375

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

 

376

                                 _patch_header_date(old_tree, file_id,

 

377

                                                    old_path))

 

378

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

 

379

                                 _patch_header_date(new_tree, file_id,

 

380

                                                    new_path))

 

381

        _maybe_diff_file_or_symlink(old_name, old_tree, file_id,

 

382

                                    new_name, new_tree,

226

383

                                    text_modified, kind, to_file, diff_file)

227

384

    for path, file_id, kind, text_modified, meta_modified in delta.modified:

 

385

        has_changes = 1

228

386

        prop_str = get_prop_change(meta_modified)

229

 

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

 

387

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

 

388

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

 

389

                                 _patch_header_date(old_tree, file_id, path))

 

390

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

 

391

                                 _patch_header_date(new_tree, file_id, path))

230

392

        if text_modified:

231

 

            _maybe_diff_file_or_symlink(old_label, path, old_tree, file_id,

232

 

                                        new_label, path, new_tree,

 

393

            _maybe_diff_file_or_symlink(old_name, old_tree, file_id,

 

394

                                        new_name, new_tree,

233

395

                                        True, kind, to_file, diff_file)

 

396

 

 

397

    return has_changes

 

398

 

 

399

 

 

400

def _patch_header_date(tree, file_id, path):

 

401

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

 

402

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

 

403

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

 

404

 

 

405

 

 

406

def _raise_if_nonexistent(paths, old_tree, new_tree):

 

407

    """Complain if paths are not in either inventory or tree.

 

408

 

 

409

    It's OK with the files exist in either tree's inventory, or 

 

410

    if they exist in the tree but are not versioned.

234

411

    

 

412

    This can be used by operations such as bzr status that can accept

 

413

    unknown or ignored files.

 

414

    """

 

415

    mutter("check paths: %r", paths)

 

416

    if not paths:

 

417

        return

 

418

    s = old_tree.filter_unversioned_files(paths)

 

419

    s = new_tree.filter_unversioned_files(s)

 

420

    s = [path for path in s if not new_tree.has_filename(path)]

 

421

    if s:

 

422

        raise errors.PathsDoNotExist(sorted(s))

 

423

 

235

424

 

236

425

def get_prop_change(meta_modified):

237

426

    if meta_modified:

240

429

        return  ""

241

430

 

242

431

 

243

 

def _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,

244

 

                                new_label, new_path, new_tree, text_modified,

 

432

def _maybe_diff_file_or_symlink(old_path, old_tree, file_id,

 

433

                                new_path, new_tree, text_modified,

245

434

                                kind, to_file, diff_file):

246

435

    if text_modified:

247

436

        new_entry = new_tree.inventory[file_id]

248

437

        old_tree.inventory[file_id].diff(diff_file,

249

 

                                         old_label + old_path, old_tree,

250

 

                                         new_label + new_path, new_entry, 

 

438

                                         old_path, old_tree,

 

439

                                         new_path, new_entry, 

251

440

                                         new_tree, to_file)

• Older »

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