← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Jelmer Vernooij
  • Date: 2012-01-23 19:08:05 UTC
  • mfrom: (6437.3.20 2.5)
  • mto: This revision was merged to the branch mainline in revision 6450.
  • Revision ID: jelmer@samba.org-20120123190805-hlcuihkt2dep44cw
merge bzr 2.5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
from bzrlib.lazy_import import lazy_import
18
20
lazy_import(globals(), """
19
21
import itertools
20
22
import time
21
23
 
22
24
from bzrlib import (
23
 
    bzrdir,
24
25
    config,
25
26
    controldir,
26
27
    debug,
39
40
""")
40
41
 
41
42
from bzrlib import (
 
43
    bzrdir,
42
44
    errors,
43
45
    registry,
44
46
    symbol_versioning,
78
80
    # being committed to
79
81
    updates_branch = False
80
82
 
81
 
    def __init__(self, repository, parents, config, timestamp=None,
 
83
    def __init__(self, repository, parents, config_stack, timestamp=None,
82
84
                 timezone=None, committer=None, revprops=None,
83
85
                 revision_id=None, lossy=False):
84
86
        """Initiate a CommitBuilder.
93
95
        :param lossy: Whether to discard data that can not be natively
94
96
            represented, when pushing to a foreign VCS 
95
97
        """
96
 
        self._config = config
 
98
        self._config_stack = config_stack
97
99
        self._lossy = lossy
98
100
 
99
101
        if committer is None:
100
 
            self._committer = self._config.username()
 
102
            self._committer = self._config_stack.get('email')
101
103
        elif not isinstance(committer, unicode):
102
104
            self._committer = committer.decode() # throw if non-ascii
103
105
        else:
711
713
    def create_bundle(self, target, base, fileobj, format=None):
712
714
        return serializer.write_bundle(self, target, base, fileobj, format)
713
715
 
714
 
    def get_commit_builder(self, branch, parents, config, timestamp=None,
 
716
    def get_commit_builder(self, branch, parents, config_stack, timestamp=None,
715
717
                           timezone=None, committer=None, revprops=None,
716
718
                           revision_id=None, lossy=False):
717
719
        """Obtain a CommitBuilder for this repository.
718
720
 
719
721
        :param branch: Branch to commit to.
720
722
        :param parents: Revision ids of the parents of the new revision.
721
 
        :param config: Configuration to use.
 
723
        :param config_stack: Configuration stack to use.
722
724
        :param timestamp: Optional timestamp recorded for commit.
723
725
        :param timezone: Optional timezone for timestamp.
724
726
        :param committer: Optional committer to set for commit.
1291
1293
        """Returns the policy for making working trees on new branches."""
1292
1294
        return not self._transport.has('no-working-trees')
1293
1295
 
 
1296
    @needs_write_lock
 
1297
    def update_feature_flags(self, updated_flags):
 
1298
        """Update the feature flags for this branch.
 
1299
 
 
1300
        :param updated_flags: Dictionary mapping feature names to necessities
 
1301
            A necessity can be None to indicate the feature should be removed
 
1302
        """
 
1303
        self._format._update_feature_flags(updated_flags)
 
1304
        self.control_transport.put_bytes('format', self._format.as_string())
 
1305
 
1294
1306
 
1295
1307
class RepositoryFormatRegistry(controldir.ControlComponentFormatRegistry):
1296
1308
    """Repository format registry."""
1409
1421
        return not self == other
1410
1422
 
1411
1423
    @classmethod
1412
 
    def find_format(klass, a_bzrdir):
1413
 
        """Return the format for the repository object in a_bzrdir.
1414
 
 
1415
 
        This is used by bzr native formats that have a "format" file in
1416
 
        the repository.  Other methods may be used by different types of
1417
 
        control directory.
1418
 
        """
1419
 
        try:
1420
 
            transport = a_bzrdir.get_repository_transport(None)
1421
 
            format_string = transport.get_bytes("format")
1422
 
            return format_registry.get(format_string)
1423
 
        except errors.NoSuchFile:
1424
 
            raise errors.NoRepositoryPresent(a_bzrdir)
1425
 
        except KeyError:
1426
 
            raise errors.UnknownFormatError(format=format_string,
1427
 
                                            kind='repository')
1428
 
 
1429
 
    @classmethod
1430
1424
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1431
1425
    def register_format(klass, format):
1432
1426
        format_registry.register(format)
1442
1436
        """Return the current default format."""
1443
1437
        return format_registry.get_default()
1444
1438
 
1445
 
    def get_format_string(self):
1446
 
        """Return the ASCII format string that identifies this format.
1447
 
 
1448
 
        Note that in pre format ?? repositories the format string is
1449
 
        not permitted nor written to disk.
1450
 
        """
1451
 
        raise NotImplementedError(self.get_format_string)
1452
 
 
1453
1439
    def get_format_description(self):
1454
1440
        """Return the short description for this format."""
1455
1441
        raise NotImplementedError(self.get_format_description)
1521
1507
            hook(params)
1522
1508
 
1523
1509
 
1524
 
class MetaDirRepositoryFormat(RepositoryFormat):
 
1510
class RepositoryFormatMetaDir(bzrdir.BzrFormat, RepositoryFormat):
1525
1511
    """Common base class for the new repositories using the metadir layout."""
1526
1512
 
1527
1513
    rich_root_data = False
1537
1523
        return matching
1538
1524
 
1539
1525
    def __init__(self):
1540
 
        super(MetaDirRepositoryFormat, self).__init__()
 
1526
        RepositoryFormat.__init__(self)
 
1527
        bzrdir.BzrFormat.__init__(self)
1541
1528
 
1542
1529
    def _create_control_files(self, a_bzrdir):
1543
1530
        """Create the required files and the initial control_files object."""
1567
1554
        finally:
1568
1555
            control_files.unlock()
1569
1556
 
1570
 
    def network_name(self):
1571
 
        """Metadir formats have matching disk and network format strings."""
1572
 
        return self.get_format_string()
 
1557
    @classmethod
 
1558
    def find_format(klass, a_bzrdir):
 
1559
        """Return the format for the repository object in a_bzrdir.
 
1560
 
 
1561
        This is used by bzr native formats that have a "format" file in
 
1562
        the repository.  Other methods may be used by different types of
 
1563
        control directory.
 
1564
        """
 
1565
        try:
 
1566
            transport = a_bzrdir.get_repository_transport(None)
 
1567
            format_string = transport.get_bytes("format")
 
1568
        except errors.NoSuchFile:
 
1569
            raise errors.NoRepositoryPresent(a_bzrdir)
 
1570
        return klass._find_format(format_registry, 'repository', format_string)
 
1571
 
 
1572
    def check_support_status(self, allow_unsupported, recommend_upgrade=True,
 
1573
            basedir=None):
 
1574
        RepositoryFormat.check_support_status(self,
 
1575
            allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
 
1576
            basedir=basedir)
 
1577
        bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
 
1578
            recommend_upgrade=recommend_upgrade, basedir=basedir)
1573
1579
 
1574
1580
 
1575
1581
# formats which have no format string are not discoverable or independently