~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

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

• reverse the comparison (1092.2.25 to 1948.4.11)
• stop comparing with revision 1948.4.11

Show diffs side-by-side

added

removed

bzrlib/revisionspec.py

1

1

# Copyright (C) 2005 Canonical Ltd

2

 

#

 

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

17

 

18

 

import bisect

19

18

import datetime

20

19

import re

21

 

 

22

 

from bzrlib import (

23

 

    errors,

24

 

    )

25

20

from bzrlib.errors import BzrError, NoSuchRevision, NoCommits

26

21

 

27

22

_marker = []

62

57

        # TODO: otherwise, it should depend on how I was built -

63

58

        # if it's in_history(branch), then check revision_history(),

64

59

        # if it's in_store(branch), do the check below

65

 

        return self.branch.repository.has_revision(self.rev_id)

 

60

        return self.rev_id in self.branch.revision_store

66

61

 

67

62

    def __len__(self):

68

63

        return 2

73

68

        raise IndexError(index)

74

69

 

75

70

    def get(self):

76

 

        return self.branch.repository.get_revision(self.rev_id)

 

71

        return self.branch.get_revision(self.rev_id)

77

72

 

78

73

    def __eq__(self, other):

79

74

        if type(other) not in (tuple, list, type(self)):

148

143

            # special case - the empty tree

149

144

            return info

150

145

        elif self.prefix:

151

 

            raise errors.InvalidRevisionSpec(self.prefix + self.spec, branch)

 

146

            raise NoSuchRevision(branch, self.prefix + str(self.spec))

152

147

        else:

153

 

            raise errors.InvalidRevisionSpec(self.spec, branch)

 

148

            raise NoSuchRevision(branch, str(self.spec))

154

149

 

155

150

    def in_history(self, branch):

156

 

        if branch:

157

 

            revs = branch.revision_history()

158

 

        else:

159

 

            revs = None

 

151

        revs = branch.revision_history()

160

152

        return self._match_on_and_check(branch, revs)

161

153

 

162

 

        # FIXME: in_history is somewhat broken,

163

 

        # it will return non-history revisions in many

164

 

        # circumstances. The expected facility is that

165

 

        # in_history only returns revision-history revs,

166

 

        # in_store returns any rev. RBC 20051010

167

 

    # aliases for now, when we fix the core logic, then they

168

 

    # will do what you expect.

169

 

    in_store = in_history

170

 

    in_branch = in_store

171

 

        

172

154

    def __repr__(self):

173

155

        # this is mostly for helping with testing

174

156

        return '<%s %s%s>' % (self.__class__.__name__,

175

157

                              self.prefix or '',

176

158

                              self.spec)

177

 

    

178

 

    def needs_branch(self):

179

 

        """Whether this revision spec needs a branch.

180

159

 

181

 

        Set this to False the branch argument of _match_on is not used.

182

 

        """

183

 

        return True

184

160

 

185

161

# private API

186

162

 

187

163

class RevisionSpec_int(RevisionSpec):

188

164

    """Spec is a number.  Special case."""

189

 

 

190

165

    def __init__(self, spec):

191

166

        self.spec = int(spec)

192

167

 

195

170

            revno = len(revs) + self.spec + 1

196

171

        else:

197

172

            revno = self.spec

198

 

        try:

199

 

            rev_id = branch.get_rev_id(revno, revs)

200

 

        except NoSuchRevision:

201

 

            raise errors.InvalidRevisionSpec(self.spec, branch)

 

173

        rev_id = branch.get_rev_id(revno, revs)

202

174

        return RevisionInfo(branch, revno, rev_id)

203

175

 

204

176

 

207

179

 

208

180

    def _match_on(self, branch, revs):

209

181

        """Lookup a revision by revision number"""

210

 

        loc = self.spec.find(':')

211

 

        if loc == -1:

212

 

            revno_spec = self.spec

213

 

            branch_spec = None

214

 

        else:

215

 

            revno_spec = self.spec[:loc]

216

 

            branch_spec = self.spec[loc+1:]

217

 

 

218

 

        if revno_spec == '':

219

 

            if not branch_spec:

220

 

                raise errors.InvalidRevisionSpec(self.prefix + self.spec,

221

 

                        branch, 'cannot have an empty revno and no branch')

222

 

            revno = None

223

 

        else:

224

 

            try:

225

 

                revno = int(revno_spec)

226

 

            except ValueError, e:

227

 

                raise errors.InvalidRevisionSpec(self.prefix + self.spec,

228

 

                                                 branch, e)

229

 

 

230

 

            if revno < 0:

231

 

                revno = len(revs) + revno + 1

232

 

 

233

 

        if branch_spec:

234

 

            from bzrlib.branch import Branch

235

 

            branch = Branch.open(branch_spec)

236

 

 

237

182

        try:

238

 

            revid = branch.get_rev_id(revno)

239

 

        except NoSuchRevision:

240

 

            raise errors.InvalidRevisionSpec(self.prefix + self.spec, branch)

241

 

 

242

 

        return RevisionInfo(branch, revno)

243

 

        

244

 

    def needs_branch(self):

245

 

        return self.spec.find(':') == -1

 

183

            return RevisionInfo(branch, int(self.spec))

 

184

        except ValueError:

 

185

            return RevisionInfo(branch, None)

246

186

 

247

187

SPEC_TYPES.append(RevisionSpec_revno)

248

188

 

252

192

 

253

193

    def _match_on(self, branch, revs):

254

194

        try:

255

 

            revno = revs.index(self.spec) + 1

 

195

            return RevisionInfo(branch, revs.index(self.spec) + 1, self.spec)

256

196

        except ValueError:

257

 

            revno = None

258

 

        return RevisionInfo(branch, revno, self.spec)

 

197

            return RevisionInfo(branch, None)

259

198

 

260

199

SPEC_TYPES.append(RevisionSpec_revid)

261

200

 

265

204

    prefix = 'last:'

266

205

 

267

206

    def _match_on(self, branch, revs):

268

 

        if self.spec == '':

269

 

            if not revs:

270

 

                raise NoCommits(branch)

271

 

            return RevisionInfo(branch, len(revs), revs[-1])

272

 

 

273

207

        try:

274

208

            offset = int(self.spec)

275

 

        except ValueError, e:

276

 

            raise errors.InvalidRevisionSpec(self.prefix + self.spec, branch, e)

277

 

 

278

 

        if offset <= 0:

279

 

            raise errors.InvalidRevisionSpec(self.prefix + self.spec, branch,

280

 

                                             'you must supply a positive value')

281

 

        revno = len(revs) - offset + 1

282

 

        try:

283

 

            revision_id = branch.get_rev_id(revno, revs)

284

 

        except errors.NoSuchRevision:

285

 

            raise errors.InvalidRevisionSpec(self.prefix + self.spec, branch)

286

 

        return RevisionInfo(branch, revno, revision_id)

 

209

        except ValueError:

 

210

            return RevisionInfo(branch, None)

 

211

        else:

 

212

            if offset <= 0:

 

213

                raise BzrError('You must supply a positive value for --revision last:XXX')

 

214

            return RevisionInfo(branch, len(revs) - offset + 1)

287

215

 

288

216

SPEC_TYPES.append(RevisionSpec_last)

289

217

 

305

233

    prefix = 'tag:'

306

234

 

307

235

    def _match_on(self, branch, revs):

308

 

        raise errors.InvalidRevisionSpec(self.prefix + self.spec, branch,

309

 

                                         'tag: namespace registered,'

310

 

                                         ' but not implemented')

 

236

        raise BzrError('tag: namespace registered, but not implemented.')

311

237

 

312

238

SPEC_TYPES.append(RevisionSpec_tag)

313

239

 

314

240

 

315

 

class RevisionSpec_revs:

316

 

    def __init__(self, revs, branch):

317

 

        self.revs = revs

318

 

        self.branch = branch

319

 

    def __getitem__(self, index):

320

 

        r = self.branch.repository.get_revision(self.revs[index])

321

 

        # TODO: Handle timezone.

322

 

        return datetime.datetime.fromtimestamp(r.timestamp)

323

 

    def __len__(self):

324

 

        return len(self.revs)

325

 

 

326

 

 

327

241

class RevisionSpec_date(RevisionSpec):

328

242

    prefix = 'date:'

329

243

    _date_re = re.compile(

341

255

          at a specified time).

342

256

 

343

257

          So the proper way of saying 'give me all entries for today' is:

344

 

              -r date:yesterday..date:today

 

258

              -r date:today..date:tomorrow

345

259

        """

346

260

        today = datetime.datetime.fromordinal(datetime.date.today().toordinal())

347

261

        if self.spec.lower() == 'yesterday':

371

285

 

372

286

            dt = datetime.datetime(year=year, month=month, day=day,

373

287

                    hour=hour, minute=minute, second=second)

374

 

        branch.lock_read()

375

 

        try:

376

 

            rev = bisect.bisect(RevisionSpec_revs(revs, branch), dt)

377

 

        finally:

378

 

            branch.unlock()

379

 

        if rev == len(revs):

380

 

            return RevisionInfo(branch, None)

381

 

        else:

382

 

            return RevisionInfo(branch, rev + 1)

 

288

        first = dt

 

289

        for i in range(len(revs)):

 

290

            r = branch.get_revision(revs[i])

 

291

            # TODO: Handle timezone.

 

292

            dt = datetime.datetime.fromtimestamp(r.timestamp)

 

293

            if first <= dt:

 

294

                return RevisionInfo(branch, i+1)

 

295

        return RevisionInfo(branch, None)

383

296

 

384

297

SPEC_TYPES.append(RevisionSpec_date)

385

298

 

390

303

    def _match_on(self, branch, revs):

391

304

        from branch import Branch

392

305

        from revision import common_ancestor, MultipleRevisionSources

393

 

        other_branch = Branch.open_containing(self.spec)[0]

 

306

        other_branch = Branch.open_containing(self.spec)

394

307

        revision_a = branch.last_revision()

395

308

        revision_b = other_branch.last_revision()

396

309

        for r, b in ((revision_a, branch), (revision_b, other_branch)):

397

310

            if r is None:

398

311

                raise NoCommits(b)

399

 

        revision_source = MultipleRevisionSources(branch.repository,

400

 

                                                  other_branch.repository)

 

312

        revision_source = MultipleRevisionSources(branch, other_branch)

401

313

        rev_id = common_ancestor(revision_a, revision_b, revision_source)

402

314

        try:

403

315

            revno = branch.revision_id_to_revno(rev_id)

406

318

        return RevisionInfo(branch, revno, rev_id)

407

319

        

408

320

SPEC_TYPES.append(RevisionSpec_ancestor)

409

 

 

410

 

class RevisionSpec_branch(RevisionSpec):

411

 

    """A branch: revision specifier.

412

 

 

413

 

    This takes the path to a branch and returns its tip revision id.

414

 

    """

415

 

    prefix = 'branch:'

416

 

 

417

 

    def _match_on(self, branch, revs):

418

 

        from branch import Branch

419

 

        other_branch = Branch.open_containing(self.spec)[0]

420

 

        revision_b = other_branch.last_revision()

421

 

        if revision_b is None:

422

 

            raise NoCommits(other_branch)

423

 

        # pull in the remote revisions so we can diff

424

 

        branch.fetch(other_branch, revision_b)

425

 

        try:

426

 

            revno = branch.revision_id_to_revno(revision_b)

427

 

        except NoSuchRevision:

428

 

            revno = None

429

 

        return RevisionInfo(branch, revno, revision_b)

430

 

        

431

 

SPEC_TYPES.append(RevisionSpec_branch)

• Older »

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