/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 13:06:23 UTC
  • Revision ID: tim@ed.am-20210901130623-2yv2y02e3zwgd07y
fix newlines in resolve command

Show diffs side-by-side

added added

removed removed

lib/stdhome/vcs/brz.py
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 st
103
 
                output = self.run( [ 'bzr', 'status' ] )
 
123
                # brz st
 
124
                output = self.run( [ 'brz', 'status' ] )
104
125
                files = self.parse_file_blocks( output )
105
126
 
106
 
                # remove kind changed files (or they can cause `bzr revert` to break in
 
127
                # remove kind changed files (or they can cause `brz revert` to break in
107
128
                # strange situations, like when a directory has been replaced with a
108
129
                # symlink to a non-existant file)
109
130
                if 'kind changed' in files:
110
131
                        for file in files[ 'kind changed' ]:
111
 
                                matches = re.match( r'(.+?)[/@+]? \([^)]+\)', file )
 
132
                                matches = re.search( '^(.+?)[/@+]? \([^)]+\)$', file )
112
133
                                if not matches:
113
134
                                        raise RunTimeError(
114
 
                                                'failed to parse bzr kind change: %s' % file )
 
135
                                                'failed to parse brz kind change: %s' % file )
115
136
                                file = matches.group( 1 )
116
 
                                if the.verbose >= 2: print "removing (kind changed): " + file
 
137
                                if the.verbose >= 2: print("removing (kind changed): " + file)
117
138
                                full_file = os.path.join( self.dir, file )
118
139
                                if os.path.isfile( full_file ) or os.path.islink( full_file ):
119
140
                                        os.unlink( full_file )
122
143
                                else:
123
144
                                        raise RuntimeError( 'exotic file in repo: %s' % file )
124
145
 
125
 
                # bzr revert
126
 
                self.run( [ 'bzr', 'revert', '--no-backup' ] )
 
146
                # brz revert
 
147
                self.run( [ 'brz', 'revert', '--no-backup' ] )
127
148
 
128
 
                # bzr st
129
 
                output = self.run( [ 'bzr', 'status' ] )
 
149
                # brz st
 
150
                output = self.run( [ 'brz', 'status' ] )
130
151
                files = self.parse_file_blocks( output )
131
152
 
132
153
                # remove unknown files
133
154
                if 'unknown' in files:
134
155
                        for file in files[ 'unknown' ]:
135
 
                                if the.verbose >= 2: 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)
136
162
                                full_file = os.path.join( self.dir, file )
137
 
                                if os.path.isfile( full_file ):
 
163
                                if os.path.isfile( full_file ) or os.path.islink( full_file ):
138
164
                                        os.unlink( full_file )
139
165
                                elif os.path.isdir( full_file ):
140
166
                                        shutil.rmtree( full_file )
141
167
                                else:
142
168
                                        raise RuntimeError( 'exotic file in repo: %s' % file )
143
169
 
144
 
                # if a revision identifyer has been given, update to that
145
 
                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:
146
172
 
147
 
                        # bzr update
148
 
                        self.run( [ 'bzr', 'update', '-r', revno ] )
 
173
                        # brz update
 
174
                        self.run( [ 'brz', 'update', '-r', revno ] )
149
175
 
150
176
 
151
177
        def update( self ):
154
180
                operation.
155
181
                """
156
182
 
157
 
#               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
158
184
#               once during an update!!!
159
185
#
160
186
#               # get revno
161
187
#               revno = self.get_revno()
162
188
#
163
189
#               # update to current revision (pull in history without updating tree)
164
 
#               self.run( [ 'bzr', 'update', '-r', revno ] )
 
190
#               self.run( [ 'brz', 'update', '-r', revno ] )
165
191
#
166
192
#               # get log output
167
193
#               next_revno = str( int( revno ) + 1 )
168
 
#               output = self.run( [ 'bzr', 'log', '-r', next_revno + '..' ] )
 
194
#               output = self.run( [ 'brz', 'log', '-r', next_revno + '..' ] )
169
195
#
170
196
#               # parse output
171
197
#               keep_files = list()
193
219
#                                                       rename_from = rename_files[ rename_from ]
194
220
#                                               rename_files[ line[ 4 : ] ] = rename_from
195
221
 
196
 
                # bzr update properly
197
 
                output = self.run( [ 'bzr', 'update' ] )
 
222
                # brz update properly
 
223
                output = self.run( [ 'brz', 'update' ] )
198
224
 
199
225
                # parse output (see logic in report() in bzrlib/delta.py)
200
226
                files = list()
201
 
                buf = StringIO.StringIO( output )
 
227
                buf = io.StringIO( output )
202
228
                for line in buf:
203
229
                        if not re.search( '^[-R+ ?][K NMD!][* ] ', line ): continue
204
230
                        line = line.rstrip()
205
 
                        if the.verbose >= 2: print '  %s' % line
206
231
 
207
232
                        # renames show before and after file names
208
233
                        matches = re.search( '^R.. (.*?)[/@+]? => (.*?)[/@+]?$', line )
224
249
                                continue
225
250
 
226
251
                        raise RuntimeError(
227
 
                                'failed to parse bzr update output line:\n%s' % line )
 
252
                                'failed to parse brz update output line:\n%s' % line )
228
253
 
229
254
                return files
230
255
 
231
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
 
232
270
        def has_changes( self ):
233
271
                """Check if the branch has any local modifications.
234
272
                """
235
273
 
236
 
                # bzr status
237
 
                output = self.run( [ 'bzr', 'status', '--no-pending' ] )
 
274
                # brz status
 
275
                output = self.run( [ 'brz', 'status', '--no-pending' ] )
238
276
 
239
277
                # parse output
240
278
                files = self.parse_file_blocks( output )
245
283
                """Return a list of files that have conflicts.
246
284
                """
247
285
 
248
 
                # bzr status
249
 
                output = self.run( [ 'bzr', 'status', '--no-pending' ] )
 
286
                # brz status
 
287
                output = self.run( [ 'brz', 'status', '--no-pending' ] )
250
288
 
251
289
                # parse output
252
290
                files = self.parse_file_blocks( output )
253
291
                return files['conflicts'] if 'conflicts' in files else None
254
292
 
255
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
 
256
319
        def run( self, cmd ):
257
 
                if the.verbose >= 2: print 'exec: %s' % ' '.join( cmd )
 
320
                if the.verbose >= 2: print('exec: %s' % ' '.join( cmd ))
258
321
                p = Popen( cmd, cwd = self.dir,
259
322
                                   stdout = subprocess.PIPE, stderr = subprocess.STDOUT )
260
 
                output = p.communicate()[ 0 ]
 
323
                output = p.communicate()[ 0 ].decode()
261
324
                if p.returncode > 0:
262
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 ))
263
330
                return output
264
331
 
265
332
 
266
333
        def parse_file_blocks( self, output ):
267
334
                res = dict()
268
335
                current = None
269
 
                buf = StringIO.StringIO( output )
 
336
                buf = io.StringIO( output )
270
337
                for line in buf:
271
338
                        matches = re.search( '^([a-z ]+):$', line, re.I )
272
339
                        if matches: