def setUp(self):
super(TestRegistryIter, self).setUp()
# We create a registry with "official" objects and "hidden"
# objects. The later represent the side effects that led to bug #277048
# and #430510
_registry = registry.Registry()
def register_more():
_registry.register('hidden', None)
# Avoid closing over self by binding local variable
self.registry = _registry
self.registry.register('passive', None)
self.registry.register('active', register_more)
self.registry.register('passive-too', None)
class InvasiveGetter(registry._ObjectGetter):
def get_obj(inner_self):
# Surprise ! Getting a registered object (think lazy loaded
# module) register yet another object !
_registry.register('more hidden', None)
return inner_self._obj
self.registry.register('hacky', None)
# We peek under the covers because the alternative is to use lazy
# registration and create a module that can reference our test registry
# it's too much work for such a corner case -- vila 090916
self.registry._dict['hacky'] = InvasiveGetter(None)
def test_registry_info(self):
a_registry = registry.Registry()
a_registry.register('one', 1, info='string info')
# We should not have to import the module to return the info
a_registry.register_lazy('two', 'nonexistent_module', 'member',
info=2)
# We should be able to handle a callable to get information
a_registry.register('three', 3, info=['a', 'list'])
obj = object()
a_registry.register_lazy('four', 'nonexistent_module', 'member2',
info=obj)
a_registry.register('five', 5)
self.assertEqual('string info', a_registry.get_info('one'))
self.assertEqual(2, a_registry.get_info('two'))
self.assertEqual(['a', 'list'], a_registry.get_info('three'))
self.assertIs(obj, a_registry.get_info('four'))
self.assertIs(None, a_registry.get_info('five'))
self.assertRaises(KeyError, a_registry.get_info, None)
self.assertRaises(KeyError, a_registry.get_info, 'six')
a_registry.default_key = 'one'
self.assertEqual('string info', a_registry.get_info(None))
self.assertRaises(KeyError, a_registry.get_info, 'six')
self.assertEqual([('five', None),
('four', obj),
('one', 'string info'),
('three', ['a', 'list']),
('two', 2),
], sorted((key, a_registry.get_info(key))
for key in a_registry.keys()))
def from_kwargs(name_,
help=None,
title=None,
value_switches=False,
enum_switch=True,
**kwargs):
"""Convenience method to generate string-map registry options
name, help, value_switches and enum_switch are passed to the
RegistryOption constructor. Any other keyword arguments are treated
as values for the option, and their value is treated as the help.
"""
reg = _mod_registry.Registry()
for name, switch_help in sorted(kwargs.items()):
name = name.replace('_', '-')
reg.register(name, name, help=switch_help)
if not value_switches:
help = help + ' "' + name + '": ' + switch_help
if not help.endswith("."):
help = help + "."
return RegistryOption(name_,
help,
reg,
title=title,
value_switches=value_switches,
enum_switch=enum_switch)
def setUp(self):
super(TestCaseWithoutPropsHandler, self).setUp()
# keep a reference to the "current" custom prop. handler registry
self.properties_handler_registry = \
log.properties_handler_registry
# clean up the registry in log
log.properties_handler_registry = registry.Registry()
def test_normal_get_module(self):
class AThing(object):
"""Something"""
a_registry = registry.Registry()
a_registry.register("obj", AThing())
self.assertEqual("bzrlib.tests.test_registry",
a_registry._get_module("obj"))
def test_registry_help(self):
a_registry = registry.Registry()
a_registry.register('one', 1, help='help text for one')
# We should not have to import the module to return the help
# information
a_registry.register_lazy('two', 'nonexistent_module', 'member',
help='help text for two')
# We should be able to handle a callable to get information
help_calls = []
def generic_help(reg, key):
help_calls.append(key)
return 'generic help for %s' % (key,)
a_registry.register('three', 3, help=generic_help)
a_registry.register_lazy('four', 'nonexistent_module', 'member2',
help=generic_help)
a_registry.register('five', 5)
def help_from_object(reg, key):
obj = reg.get(key)
return obj.help()
class SimpleObj(object):
def help(self):
return 'this is my help'
a_registry.register('six', SimpleObj(), help=help_from_object)
self.assertEqual('help text for one', a_registry.get_help('one'))
self.assertEqual('help text for two', a_registry.get_help('two'))
self.assertEqual('generic help for three',
a_registry.get_help('three'))
self.assertEqual(['three'], help_calls)
self.assertEqual('generic help for four',
a_registry.get_help('four'))
self.assertEqual(['three', 'four'], help_calls)
self.assertEqual(None, a_registry.get_help('five'))
self.assertEqual('this is my help', a_registry.get_help('six'))
self.assertRaises(KeyError, a_registry.get_help, None)
self.assertRaises(KeyError, a_registry.get_help, 'seven')
a_registry.default_key = 'one'
self.assertEqual('help text for one', a_registry.get_help(None))
self.assertRaises(KeyError, a_registry.get_help, 'seven')
self.assertEqual([('five', None),
('four', 'generic help for four'),
('one', 'help text for one'),
('six', 'this is my help'),
('three', 'generic help for three'),
('two', 'help text for two'),
], sorted((key, a_registry.get_help(key))
for key in a_registry.keys()))
# We don't know what order it was called in, but we should get
# 2 more calls to three and four
self.assertEqual(['four', 'four', 'three', 'three'],
sorted(help_calls))
def test_short_value_switches(self):
reg = registry.Registry()
reg.register('short', 'ShortChoice')
reg.register('long', 'LongChoice')
ropt = option.RegistryOption('choice', '', reg, value_switches=True,
short_value_switches={'short': 's'})
opts, args = parse([ropt], ['--short'])
self.assertEqual('ShortChoice', opts.choice)
opts, args = parse([ropt], ['-s'])
self.assertEqual('ShortChoice', opts.choice)
def test_get_prefix(self):
my_registry = registry.Registry()
http_object = object()
sftp_object = object()
my_registry.register('http:', http_object)
my_registry.register('sftp:', sftp_object)
found_object, suffix = my_registry.get_prefix('http://foo/bar')
self.assertEqual('//foo/bar', suffix)
self.assertIs(http_object, found_object)
self.assertIsNot(sftp_object, found_object)
found_object, suffix = my_registry.get_prefix('sftp://baz/qux')
self.assertEqual('//baz/qux', suffix)
self.assertIs(sftp_object, found_object)
def test_registry_funcs(self):
a_registry = registry.Registry()
self.register_stuff(a_registry)
self.failUnless('one' in a_registry)
a_registry.remove('one')
self.failIf('one' in a_registry)
self.assertRaises(KeyError, a_registry.get, 'one')
a_registry.register('one', 'one')
self.assertEqual(['five', 'four', 'one', 'two'],
sorted(a_registry.keys()))
self.assertEqual([('five', 5), ('four', 4), ('one', 'one'),
('two', 2)], sorted(a_registry.iteritems()))
def test_register_override(self):
a_registry = registry.Registry()
a_registry.register('one', 'one')
self.assertRaises(KeyError, a_registry.register, 'one', 'two')
self.assertRaises(KeyError, a_registry.register, 'one', 'two',
override_existing=False)
a_registry.register('one', 'two', override_existing=True)
self.assertEqual('two', a_registry.get('one'))
self.assertRaises(KeyError, a_registry.register_lazy,
'one', 'three', 'four')
a_registry.register_lazy('one', 'module', 'member',
override_existing=True)
def test_lazy_import_registry(self):
plugin_name = self.create_simple_plugin()
a_registry = registry.Registry()
a_registry.register_lazy('obj', plugin_name, 'object1')
a_registry.register_lazy('function', plugin_name, 'function')
a_registry.register_lazy('klass', plugin_name, 'MyClass')
a_registry.register_lazy('module', plugin_name, None)
self.assertEqual(['function', 'klass', 'module', 'obj'],
sorted(a_registry.keys()))
# The plugin should not be loaded until we grab the first object
self.assertFalse(plugin_name in sys.modules)
# By default the plugin won't be in the search path
self.assertRaises(ImportError, a_registry.get, 'obj')
plugin_path = os.getcwd() + '/tmp'
sys.path.append(plugin_path)
try:
obj = a_registry.get('obj')
self.assertEqual('foo', obj)
self.assertTrue(plugin_name in sys.modules)
# Now grab another object
func = a_registry.get('function')
self.assertEqual(plugin_name, func.__module__)
self.assertEqual('function', func.__name__)
self.assertEqual((1, [], '3'), func(1, [], '3'))
# And finally a class
klass = a_registry.get('klass')
self.assertEqual(plugin_name, klass.__module__)
self.assertEqual('MyClass', klass.__name__)
inst = klass(1)
self.assertIsInstance(inst, klass)
self.assertEqual(1, inst.a)
module = a_registry.get('module')
self.assertIs(obj, module.object1)
self.assertIs(func, module.function)
self.assertIs(klass, module.MyClass)
finally:
sys.path.remove(plugin_path)
def test_registry_option_value_switches_hidden(self):
reg = registry.Registry()
class Hider(object):
hidden = True
reg.register("new", 1, "Current.")
reg.register("old", 0, "Legacy.", info=Hider())
opt = option.RegistryOption("protocol",
"Talking.",
reg,
value_switches=True,
enum_switch=False)
pot = self.pot_from_option(opt)
self.assertContainsString(
pot, "\n"
"# help of 'protocol' test\n"
"msgid \"Talking.\"\n")
self.assertContainsString(
pot, "\n"
"# help of 'protocol=new' test\n"
"msgid \"Current.\"\n")
self.assertNotContainsString(pot, "'protocol=old'")
def test_registry(self):
a_registry = registry.Registry()
self.register_stuff(a_registry)
self.assertTrue(a_registry.default_key is None)
# test get() (self.default_key is None)
self.assertRaises(KeyError, a_registry.get)
self.assertRaises(KeyError, a_registry.get, None)
self.assertEqual(2, a_registry.get('two'))
self.assertRaises(KeyError, a_registry.get, 'three')
# test _set_default_key
a_registry.default_key = 'five'
self.assertTrue(a_registry.default_key == 'five')
self.assertEqual(5, a_registry.get())
self.assertEqual(5, a_registry.get(None))
# If they ask for a specific entry, they should get KeyError
# not the default value. They can always pass None if they prefer
self.assertRaises(KeyError, a_registry.get, 'six')
self.assertRaises(KeyError, a_registry._set_default_key, 'six')
# test keys()
self.assertEqual(['five', 'four', 'one', 'two'], a_registry.keys())
if self._working_tree is not None:
return self._working_tree.last_revision()
return self._branch.last_revision()
def generate(self, to_file):
"""Output the version information to the supplied file.
:param to_file: The file to write the stream to. The output
will already be encoded, so to_file should not try
to change encodings.
:return: None
"""
raise NotImplementedError(VersionInfoBuilder.generate)
format_registry = registry.Registry()
format_registry.register_lazy(
'rio',
'bzrlib.version_info_formats.format_rio',
'RioVersionInfoBuilder',
'Version info in RIO (simple text) format (default).')
format_registry.default_key = 'rio'
format_registry.register_lazy(
'python',
'bzrlib.version_info_formats.format_python',
'PythonVersionInfoBuilder',
'Version info in Python format.')
format_registry.register_lazy(
'custom',
# use the lock, because you don't have the lock token. Calling lock
# again will fail, because the lock is already taken. However, we
# can't tell if the server received our request or not. If it didn't,
# then retrying the request is fine, as it will actually do what we
# want. If it did, we will interrupt the current operation, but we
# are no worse off than interrupting the current operation because of
# a ConnectionReset.
# semivfs Similar to semi, but specific to a Virtual FileSystem request.
# stream This is a request that takes a stream that cannot be restarted if
# consumed. This request is 'safe' in that if we determine the
# connection is closed before we consume the stream, we can try
# again.
# mutate State is updated in a way that replaying that request results in a
# different state. For example 'append' writes more bytes to a given
# file. If append succeeds, it moves the file pointer.
request_handlers = registry.Registry()
request_handlers.register_lazy('append',
'bzrlib.smart.vfs',
'AppendRequest',
info='mutate')
request_handlers.register_lazy('Branch.break_lock',
'bzrlib.smart.branch',
'SmartServerBranchBreakLock',
info='idem')
request_handlers.register_lazy('Branch.get_config_file',
'bzrlib.smart.branch',
'SmartServerBranchGetConfigFile',
info='read')
request_handlers.register_lazy('Branch.get_parent',
'bzrlib.smart.branch',
'SmartServerBranchGetParent',
raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
return result
# The order in which we want to DWIM a revision spec without any prefix.
# revno is always tried first and isn't listed here, this is used by
# RevisionSpec_dwim._match_on
dwim_revspecs = symbol_versioning.deprecated_list(
symbol_versioning.deprecated_in((2, 4, 0)), "dwim_revspecs", [])
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_tag)
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_revid)
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_date)
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_branch)
revspec_registry = registry.Registry()
def _register_revspec(revspec):
revspec_registry.register(revspec.prefix, revspec)
_register_revspec(RevisionSpec_revno)
_register_revspec(RevisionSpec_revid)
_register_revspec(RevisionSpec_last)
_register_revspec(RevisionSpec_before)
_register_revspec(RevisionSpec_tag)
_register_revspec(RevisionSpec_date)
_register_revspec(RevisionSpec_ancestor)
_register_revspec(RevisionSpec_branch)
_register_revspec(RevisionSpec_submit)
def setUp(self):
super(TestVersionInfoFormatRegistry, self).setUp()
self.overrideAttr(version_info_formats,
'format_registry', registry.Registry())
help='List paths of files with text conflicts.'),
]
_see_also = ['resolve', 'conflict-types']
def run(self, text=False, directory=u'.'):
wt = workingtree.WorkingTree.open_containing(directory)[0]
for conflict in wt.conflicts():
if text:
if conflict.typestring != 'text conflict':
continue
self.outf.write(conflict.path + '\n')
else:
self.outf.write(unicode(conflict) + '\n')
resolve_action_registry = registry.Registry()
resolve_action_registry.register(
'done', 'done', 'Marks the conflict as resolved.')
resolve_action_registry.register(
'take-this', 'take_this',
'Resolve the conflict preserving the version in the working tree.')
resolve_action_registry.register(
'take-other', 'take_other',
'Resolve the conflict taking the merged version into account.')
resolve_action_registry.default_key = 'done'
class ResolveActionOption(option.RegistryOption):
def __init__(self):
class AliasDirectory(object):
"""Directory lookup for locations associated with a branch.
:parent, :submit, :public, :push, :this, and :bound are currently
supported. On error, a subclass of DirectoryLookupFailure will be raised.
"""
branch_aliases = registry.Registry()
branch_aliases.register('parent',
lambda b: b.get_parent(),
help="The parent of this branch.")
branch_aliases.register('submit',
lambda b: b.get_submit_branch(),
help="The submit branch for this branch.")
branch_aliases.register('public',
lambda b: b.get_public_branch(),
help="The public location of this branch.")
branch_aliases.register(
'bound',
lambda b: b.get_bound_location(),
help="The branch this branch is bound to, for bound branches.")
branch_aliases.register(
'push',
lambda b: b.get_push_location(),
help="The saved location used for `bzr push` with no arguments.")
branch_aliases.register('this', lambda b: b.base, help="This branch.")
def look_up(self, name, url):
branch = _mod_branch.Branch.open_containing('.')[0]
parts = url.split('/', 1)
if len(parts) == 2:
name, extra = parts
else:
(name, ) = parts
extra = None
try:
method = self.branch_aliases.get(name[1:])
except KeyError:
raise errors.InvalidLocationAlias(url)
else:
result = method(branch)
if result is None:
raise errors.UnsetLocationAlias(url)
if extra is not None:
result = urlutils.join(result, extra)
return result
@classmethod
def help_text(cls, topic):
alias_lines = []
for key in cls.branch_aliases.keys():
help = cls.branch_aliases.get_help(key)
alias_lines.append(" :%-10s%s\n" % (key, help))
return """\
Location aliases
================
Bazaar defines several aliases for locations associated with a branch. These
can be used with most commands that expect a location, such as `bzr push`.
The aliases are::
%s
For example, to push to the parent location::
bzr push :parent
""" % "".join(alias_lines)
short_value_switches={'short': 'S'})
_global_registry_option('merge-type',
'Select a particular merge algorithm.',
lazy_registry=('bzrlib.merge', 'merge_type_registry'),
value_switches=True,
title='Merge algorithm')
_global_option('message', type=unicode, short_name='m', help='Message string.')
_global_option('null',
short_name='0',
help='Use an ASCII NUL (\\0) separator rather than '
'a newline.')
_global_option('overwrite',
help='Ignore differences between branches and '
'overwrite unconditionally.')
_global_option('remember',
help='Remember the specified location as a'
' default.')
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
_global_option('revision',
type=_parse_revision_str,
short_name='r',
help='See "help revisionspec" for details.')
_global_option('show-ids', help='Show internal object ids.')
_global_option('timezone',
type=str,
help='Display timezone as local, original, or utc.')
diff_writer_registry = _mod_registry.Registry()
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')
diff_writer_registry.default_key = 'plain'
def test_lazy_import_registry_foo(self):
a_registry = registry.Registry()
a_registry.register_lazy('foo', 'bzrlib.branch', 'Branch')
a_registry.register_lazy('bar', 'bzrlib.branch', 'Branch.hooks')
self.assertEqual(branch.Branch, a_registry.get('foo'))
self.assertEqual(branch.Branch.hooks, a_registry.get('bar'))
def test_lazy_import_get_module(self):
a_registry = registry.Registry()
a_registry.register_lazy('obj', "bzrlib.tests.test_registry",
'object1')
self.assertEqual("bzrlib.tests.test_registry",
a_registry._get_module("obj"))
break
if base_idx is None:
to_file.write('Nothing seems to have changed\n')
return
## TODO: It might be nice to do something like show_log
## and show the merged entries. But since this is the
## removed revisions, it shouldn't be as important
if base_idx < len(old_rh):
to_file.write('*'*60)
to_file.write('\nRemoved Revisions:\n')
for i in range(base_idx, len(old_rh)):
rev = branch.repository.get_revision(old_rh[i])
lr = LogRevision(rev, i+1, 0, None)
lf.log_revision(lr)
to_file.write('*'*60)
to_file.write('\n\n')
if base_idx < len(new_rh):
to_file.write('Added Revisions:\n')
show_log(branch,
lf,
None,
verbose=False,
direction='forward',
start_revision=base_idx+1,
end_revision=len(new_rh),
search=None)
properties_handler_registry = registry.Registry()
