/stdhome

To get this branch, use:
bzr branch http://bzr.ed.am/stdhome

« back to all changes in this revision

Viewing changes to lib/stdhome/vcs/brz.py

  • Committer: Tim Marston
  • Date: 2021-09-01 12:55:42 UTC
  • Revision ID: tim@ed.am-20210901125542-zbuzpswfo7mmm5br
fix broken use of self in @staticmethod

Show diffs side-by-side

added added

removed removed

1
 
# bzr.py
 
1
# brz.py
2
2
#
3
3
# Copyright (C) 2014 Tim Marston <tim@edm.am>
4
4
#
19
19
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
20
20
 
21
21
 
22
 
import subprocess, os, re, shutil
 
22
import io
 
23
import os
 
24
import re
 
25
import shutil
 
26
import subprocess
23
27
from subprocess import Popen
24
 
import StringIO
25
 
from vcs import Vcs
 
28
 
26
29
from stdhome import the
27
30
 
28
 
 
29
 
class BzrVcs( Vcs ):
 
31
from .vcs import Vcs
 
32
 
 
33
 
 
34
class BrzVcs( Vcs ):
30
35
 
31
36
 
32
37
        def __init__( self, dir ):
34
39
 
35
40
                @param dir the fully-qualified directory to work in.
36
41
                """
 
42
 
37
43
                self.dir = dir
 
44
                self.ignored_files = [ '.bzr', '.bzrignore' ]
 
45
 
 
46
 
 
47
        def has_authority( self ):
 
48
                """Check that the directory is under this VCS's control.
 
49
                """
 
50
 
 
51
                return os.path.exists( os.path.join( self.dir, '.bzr' ) )
 
52
 
 
53
 
 
54
        def expand_repo_url( self, url ):
 
55
                """Convert a simple hostname in to an URL that the VCS can use.
 
56
                """
 
57
 
 
58
                return 'bzr+ssh://%s/%s/%s' % ( url, the.dir, the.repo.name )
38
59
 
39
60
 
40
61
        def init( self ):
44
65
                # the directory shouldn't exist
45
66
                os.mkdir( self.dir )
46
67
 
47
 
                # bzr init
 
68
                # brz init
48
69
                try:
49
 
                        self.run( [ 'bzr', 'init', '.' ] )
 
70
                        self.run( [ 'brz', 'init', '.' ] )
50
71
                except self.VcsError as e:
51
72
 
52
73
                        # attempt to clean-up dir
67
88
                # the directory shouldn't exist
68
89
                os.mkdir( self.dir )
69
90
 
70
 
                # bzr co
 
91
                # brz co
71
92
                try:
72
 
                        self.run( [ 'bzr', 'checkout', url, '.' ] )
 
93
                        self.run( [ 'brz', 'checkout', url, '.' ] )
73
94
                except self.VcsError as e:
74
95
 
75
96
                        # attempt to clean-up dir
85
106
                """Obtain some sort of revision identifier
86
107
                """
87
108
 
88
 
                # bzr revert
89
 
                output = self.run( [ 'bzr', 'revno', '--tree' ] )
 
109
                # brz revno
 
110
                output = self.run( [ 'brz', 'revno', '--tree' ] )
90
111
 
91
112
                # parse revno
92
 
                buf = StringIO.StringIO( output )
 
113
                buf = io.StringIO( output )
93
114
                return buf.readline().rstrip()
94
115
 
95
116
 
99
120
                revision.
100
121
                """
101
122
 
102
 
                # bzr revert (run twice to handle a bug in bzr where reverting a
103
 
                # directory from a symlink can cause conflicts during initial revert)
104
 
                self.run( [ 'bzr', 'revert', '--no-backup' ] )
105
 
                self.run( [ 'bzr', 'revert', '--no-backup' ] )
106
 
 
107
 
                # bzr st
108
 
                output = self.run( [ 'bzr', 'status' ] )
 
123
                # brz st
 
124
                output = self.run( [ 'brz', 'status' ] )
 
125
                files = self.parse_file_blocks( output )
 
126
 
 
127
                # remove kind changed files (or they can cause `brz revert` to break in
 
128
                # strange situations, like when a directory has been replaced with a
 
129
                # symlink to a non-existant file)
 
130
                if 'kind changed' in files:
 
131
                        for file in files[ 'kind changed' ]:
 
132
                                matches = re.search( '^(.+?)[/@+]? \([^)]+\)$', file )
 
133
                                if not matches:
 
134
                                        raise RunTimeError(
 
135
                                                'failed to parse brz kind change: %s' % file )
 
136
                                file = matches.group( 1 )
 
137
                                if the.verbose >= 2: print("removing (kind changed): " + file)
 
138
                                full_file = os.path.join( self.dir, file )
 
139
                                if os.path.isfile( full_file ) or os.path.islink( full_file ):
 
140
                                        os.unlink( full_file )
 
141
                                elif os.path.isdir( full_file ):
 
142
                                        shutil.rmtree( full_file )
 
143
                                else:
 
144
                                        raise RuntimeError( 'exotic file in repo: %s' % file )
 
145
 
 
146
                # brz revert
 
147
                self.run( [ 'brz', 'revert', '--no-backup' ] )
 
148
 
 
149
                # brz st
 
150
                output = self.run( [ 'brz', 'status' ] )
109
151
                files = self.parse_file_blocks( output )
110
152
 
111
153
                # remove unknown files
112
154
                if 'unknown' in files:
113
155
                        for file in files[ 'unknown' ]:
114
 
                                if the.verbose > 1: print "removing unknown: " + file
 
156
                                matches = re.search( r'^(.+?)[/@+]?$', file )
 
157
                                if not matches:
 
158
                                        raise RunTimeError(
 
159
                                                'failed to parse brz unknowns: %s' % file )
 
160
                                file = matches.group( 1 )
 
161
                                if the.verbose >= 2: print("removing (unknown): " + file)
115
162
                                full_file = os.path.join( self.dir, file )
116
 
                                if os.path.isfile( full_file ):
 
163
                                if os.path.isfile( full_file ) or os.path.islink( full_file ):
117
164
                                        os.unlink( full_file )
118
165
                                elif os.path.isdir( full_file ):
119
166
                                        shutil.rmtree( full_file )
120
167
                                else:
121
168
                                        raise RuntimeError( 'exotic file in repo: %s' % file )
122
169
 
123
 
                # if a revision identifyer has been given, update to that
124
 
                if revno is not None:
 
170
                # if a revision identifier has been given, ensure we're updated to that
 
171
                if revno is not None and self.get_revno() != revno:
125
172
 
126
 
                        # bzr update
127
 
                        self.run( [ 'bzr', 'update', '-r', revno ] )
 
173
                        # brz update
 
174
                        self.run( [ 'brz', 'update', '-r', revno ] )
128
175
 
129
176
 
130
177
        def update( self ):
133
180
                operation.
134
181
                """
135
182
 
136
 
#               WARNING: the following might cause bzr to ask for your ssh password more than
 
183
#               WARNING: the following might cause brz to ask for your ssh password more than
137
184
#               once during an update!!!
138
185
#
139
186
#               # get revno
140
187
#               revno = self.get_revno()
141
188
#
142
189
#               # update to current revision (pull in history without updating tree)
143
 
#               self.run( [ 'bzr', 'update', '-r', revno ] )
 
190
#               self.run( [ 'brz', 'update', '-r', revno ] )
144
191
#
145
192
#               # get log output
146
193
#               next_revno = str( int( revno ) + 1 )
147
 
#               output = self.run( [ 'bzr', 'log', '-r', next_revno + '..' ] )
 
194
#               output = self.run( [ 'brz', 'log', '-r', next_revno + '..' ] )
148
195
#
149
196
#               # parse output
150
197
#               keep_files = list()
172
219
#                                                       rename_from = rename_files[ rename_from ]
173
220
#                                               rename_files[ line[ 4 : ] ] = rename_from
174
221
 
175
 
                # bzr update properly
176
 
                output = self.run( [ 'bzr', 'update' ] )
 
222
                # brz update properly
 
223
                output = self.run( [ 'brz', 'update' ] )
177
224
 
178
225
                # parse output (see logic in report() in bzrlib/delta.py)
179
226
                files = list()
180
 
                buf = StringIO.StringIO( output )
 
227
                buf = io.StringIO( output )
181
228
                for line in buf:
182
229
                        if not re.search( '^[-R+ ?][K NMD!][* ] ', line ): continue
183
230
                        line = line.rstrip()
184
 
                        if the.verbose > 1: print '  %s' % line
185
231
 
186
232
                        # renames show before and after file names
187
233
                        matches = re.search( '^R.. (.*?)[/@+]? => (.*?)[/@+]?$', line )
203
249
                                continue
204
250
 
205
251
                        raise RuntimeError(
206
 
                                'failed to parse bzr update output line:\n%' % line )
 
252
                                'failed to parse brz update output line:\n%s' % line )
207
253
 
208
254
                return files
209
255
 
210
256
 
 
257
        def status( self ):
 
258
                """Get a list of any local modifications.  This method returns a list of files
 
259
                which are modified.
 
260
 
 
261
                """
 
262
 
 
263
                # bzr status
 
264
                output = self.run( [ 'bzr', 'status', '--no-pending' ] )
 
265
 
 
266
                # parse output
 
267
                return self.parse_file_blocks( output )
 
268
 
 
269
 
211
270
        def has_changes( self ):
212
271
                """Check if the branch has any local modifications.
213
272
                """
214
273
 
215
 
                # bzr status
216
 
                output = self.run( [ 'bzr', 'status', '--no-pending' ] )
 
274
                # brz status
 
275
                output = self.run( [ 'brz', 'status', '--no-pending' ] )
217
276
 
218
277
                # parse output
219
278
                files = self.parse_file_blocks( output )
224
283
                """Return a list of files that have conflicts.
225
284
                """
226
285
 
227
 
                # bzr status
228
 
                output = self.run( [ 'bzr', 'status', '--no-pending' ] )
 
286
                # brz status
 
287
                output = self.run( [ 'brz', 'status', '--no-pending' ] )
229
288
 
230
289
                # parse output
231
290
                files = self.parse_file_blocks( output )
232
291
                return files['conflicts'] if 'conflicts' in files else None
233
292
 
234
293
 
 
294
        def add( self, files ):
 
295
                """Make sure files are added to version control.
 
296
                @param files a list of relative filenames
 
297
                """
 
298
 
 
299
                # brz add
 
300
                self.run( [ 'brz', 'add', '-N' ] + files )
 
301
 
 
302
 
 
303
        def commit( self ):
 
304
                """Commit changes to the repo.
 
305
                """
 
306
 
 
307
                # brz commit
 
308
                try:
 
309
                        self.run( [ 'brz', 'commit', '-m', '' ] )
 
310
                except self.VcsError as e:
 
311
                        if re.search( 'Working tree is out of date', e.output ):
 
312
                                raise the.program.FatalError(
 
313
                                        'you must update your files first.\n' +
 
314
                                        'Hint: see "%s update --help"' % the.program.name );
 
315
                        else:
 
316
                                raise e
 
317
 
 
318
 
235
319
        def run( self, cmd ):
236
 
                if the.verbose > 1: print 'exec: %s' % ' '.join( cmd )
 
320
                if the.verbose >= 2: print('exec: %s' % ' '.join( cmd ))
237
321
                p = Popen( cmd, cwd = self.dir,
238
322
                                   stdout = subprocess.PIPE, stderr = subprocess.STDOUT )
239
 
                output = p.communicate()[ 0 ]
 
323
                output = p.communicate()[ 0 ].decode()
240
324
                if p.returncode > 0:
241
325
                        raise self.VcsError( ' '.join( cmd[ : 2 ] ), output )
 
326
                if the.verbose >= 2:
 
327
                        verbose_output = output.rstrip()
 
328
                        if len( verbose_output ):
 
329
                                print(re.sub( '(^|\n)', '\\1  : ', verbose_output ))
242
330
                return output
243
331
 
244
332
 
245
333
        def parse_file_blocks( self, output ):
246
334
                res = dict()
247
335
                current = None
248
 
                buf = StringIO.StringIO( output )
 
336
                buf = io.StringIO( output )
249
337
                for line in buf:
250
338
                        matches = re.search( '^([a-z ]+):$', line, re.I )
251
339
                        if matches:
258
346
                                                res[ current ] = list()
259
347
                                        res[ current ].append( matches.group( 1 ) )
260
348
                                        continue
261
 
                        if re.search( '^[0-9]+ shelf exists', line ): continue
 
349
                        if re.search( '^[0-9]+ shel(?:f|ves) exists?', line ): continue
262
350
                        if re.search( '^working tree is out of date', line ): continue
263
351
                        raise self.ParseError( "unrecognised line: %s" % line )
264
352
                return res