/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/transportgit.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-11 04:08:32 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181111040832-nsljjynzzwmznf3h
Run autopep8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/transportgit.py
97
97
 
98
98
    def _ensure_dir_exists(self, path):
99
99
        for n in range(path.count("/")):
100
 
            dirname = "/".join(path.split("/")[:n+1])
 
100
            dirname = "/".join(path.split("/")[:n + 1])
101
101
            try:
102
102
                self.transport.mkdir(dirname)
103
103
            except FileExists:
126
126
        else:
127
127
            keys.add(b"HEAD")
128
128
        try:
129
 
            iter_files = list(self.transport.clone("refs").iter_files_recursive())
 
129
            iter_files = list(self.transport.clone(
 
130
                "refs").iter_files_recursive())
130
131
            for filename in iter_files:
131
132
                unquoted_filename = urlutils.unquote_to_bytes(filename)
132
133
                refname = osutils.pathjoin(b"refs", unquoted_filename)
215
216
                return header + next(iter(f)).rstrip(b"\r\n")
216
217
            else:
217
218
                # Read only the first 40 bytes
218
 
                return header + f.read(40-len(SYMREF))
 
219
                return header + f.read(40 - len(SYMREF))
219
220
 
220
221
    def _remove_packed_ref(self, name):
221
222
        if self._packed_refs is None:
250
251
            self._ensure_dir_exists(urlutils.quote_from_bytes(name))
251
252
        else:
252
253
            transport = self.worktree_transport
253
 
        transport.put_bytes(urlutils.quote_from_bytes(name), SYMREF + other + b'\n')
 
254
        transport.put_bytes(urlutils.quote_from_bytes(
 
255
            name), SYMREF + other + b'\n')
254
256
 
255
257
    def set_if_equals(self, name, old_ref, new_ref):
256
258
        """Set a refname to new_ref only if it currently equals old_ref.
274
276
        else:
275
277
            transport = self.transport
276
278
            self._ensure_dir_exists(urlutils.quote_from_bytes(realname))
277
 
        transport.put_bytes(urlutils.quote_from_bytes(realname), new_ref+b"\n")
 
279
        transport.put_bytes(urlutils.quote_from_bytes(
 
280
            realname), new_ref + b"\n")
278
281
        return True
279
282
 
280
283
    def add_if_new(self, name, ref):
300
303
        else:
301
304
            transport = self.transport
302
305
            self._ensure_dir_exists(urlutils.quote_from_bytes(realname))
303
 
        transport.put_bytes(urlutils.quote_from_bytes(realname), ref+b"\n")
 
306
        transport.put_bytes(urlutils.quote_from_bytes(realname), ref + b"\n")
304
307
        return True
305
308
 
306
309
    def remove_if_equals(self, name, old_ref):
352
355
        self._ensure_dir_exists(urlutils.quote_from_bytes(name))
353
356
        lockname = urlutils.quote_from_bytes(name + b".lock")
354
357
        try:
355
 
            local_path = self.transport.local_abspath(urlutils.quote_from_bytes(name))
 
358
            local_path = self.transport.local_abspath(
 
359
                urlutils.quote_from_bytes(name))
356
360
        except NotLocalUrl:
357
361
            # This is racy, but what can we do?
358
362
            if self.transport.has(lockname):
359
363
                raise LockContention(name)
360
 
            lock_result = self.transport.put_bytes(lockname, b'Locked by brz-git')
 
364
            lock_result = self.transport.put_bytes(
 
365
                lockname, b'Locked by brz-git')
361
366
            return LogicalLockResult(lambda: self.transport.delete(lockname))
362
367
        else:
363
368
            try:
405
410
            else:
406
411
                self._controltransport = self.transport.clone('.git')
407
412
        else:
408
 
            self._controltransport = self.transport.clone(urlutils.quote_from_bytes(path))
 
413
            self._controltransport = self.transport.clone(
 
414
                urlutils.quote_from_bytes(path))
409
415
        commondir = self.get_named_file(COMMONDIR)
410
416
        if commondir is not None:
411
417
            with commondir:
422
428
        if refs_text is not None:
423
429
            refs_container = InfoRefsContainer(BytesIO(refs_text))
424
430
            try:
425
 
                head = TransportRefsContainer(self._commontransport).read_loose_ref("HEAD")
 
431
                head = TransportRefsContainer(
 
432
                    self._commontransport).read_loose_ref("HEAD")
426
433
            except KeyError:
427
434
                pass
428
435
            else:
429
436
                refs_container._refs["HEAD"] = head
430
437
        else:
431
438
            refs_container = TransportRefsContainer(
432
 
                    self._commontransport, self._controltransport)
 
439
                self._commontransport, self._controltransport)
433
440
        super(TransportRepo, self).__init__(object_store,
434
 
                refs_container)
 
441
                                            refs_container)
435
442
 
436
443
    def controldir(self):
437
444
        return self._controltransport.local_abspath('.')
624
631
                    pd = PackData(name, f, size=len(contents))
625
632
                else:
626
633
                    pd = PackData(name, self.pack_transport.get(name),
627
 
                            size=size)
 
634
                                  size=size)
628
635
                idxname = name.replace(".pack", ".idx")
629
 
                idx = load_pack_index_file(idxname, self.pack_transport.get(idxname))
 
636
                idx = load_pack_index_file(
 
637
                    idxname, self.pack_transport.get(idxname))
630
638
                pack = Pack.from_objects(pd, idx)
631
639
                pack._basename = idxname[:-4]
632
640
                ret.append(pack)
637
645
            if len(base) != 2:
638
646
                continue
639
647
            for rest in self.transport.list_dir(base):
640
 
                yield (base+rest).encode(sys.getfilesystemencoding())
 
648
                yield (base + rest).encode(sys.getfilesystemencoding())
641
649
 
642
650
    def _split_loose_object(self, sha):
643
651
        return (sha[:2], sha[2:])
666
674
            pass
667
675
        path = urlutils.quote_from_bytes(osutils.pathjoin(dir, file))
668
676
        if self.transport.has(path):
669
 
            return # Already there, no need to write again
 
677
            return  # Already there, no need to write again
670
678
        self.transport.put_bytes(path, obj.as_legacy_object())
671
679
 
672
680
    def move_in_pack(self, f):
680
688
        f.seek(0)
681
689
        p = PackData("", f, len(f.getvalue()))
682
690
        entries = p.sorted_entries()
683
 
        basename = "pack-%s" % iter_sha1(entry[0] for entry in entries).decode('ascii')
 
691
        basename = "pack-%s" % iter_sha1(entry[0]
 
692
                                         for entry in entries).decode('ascii')
684
693
        p._filename = basename + ".pack"
685
694
        f.seek(0)
686
695
        self.pack_transport.put_file(basename + ".pack", f)
690
699
        finally:
691
700
            idxfile.close()
692
701
        idxfile = self.pack_transport.get(basename + ".idx")
693
 
        idx = load_pack_index_file(basename+".idx", idxfile)
 
702
        idx = load_pack_index_file(basename + ".idx", idxfile)
694
703
        final_pack = Pack.from_objects(p, idx)
695
704
        final_pack._basename = basename
696
705
        self._add_known_pack(basename, final_pack)
708
717
        p = Pack('', resolve_ext_ref=self.get_raw)
709
718
        p._data = PackData.from_file(f, len(f.getvalue()))
710
719
        p._data.pack = p
711
 
        p._idx_load = lambda: MemoryPackIndex(p.data.sorted_entries(), p.data.get_stored_checksum())
 
720
        p._idx_load = lambda: MemoryPackIndex(
 
721
            p.data.sorted_entries(), p.data.get_stored_checksum())
712
722
 
713
723
        pack_sha = p.index.objects_sha1()
714
724
 
715
725
        datafile = self.pack_transport.open_write_stream(
716
 
                "pack-%s.pack" % pack_sha.decode('ascii'))
 
726
            "pack-%s.pack" % pack_sha.decode('ascii'))
717
727
        try:
718
728
            entries, data_sum = write_pack_objects(datafile, p.pack_tuples())
719
729
        finally:
735
745
            call when the pack is finished.
736
746
        """
737
747
        f = BytesIO()
 
748
 
738
749
        def commit():
739
750
            if len(f.getvalue()) > 0:
740
751
                return self.move_in_pack(f)
741
752
            else:
742
753
                return None
 
754
 
743
755
        def abort():
744
756
            return None
745
757
        return f, commit, abort