def console_output(self, targets):
buildfile_aliases = self.context.build_configuration.registered_aliases(
)
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
alias = self.get_options().details
if alias:
tti = next(x for x in extracter.get_target_type_info()
if x.symbol == alias)
yield blue('\n{}\n'.format(tti.description))
yield blue('{}('.format(alias))
for arg in tti.args:
default = green('(default: {})'.format(arg.default) if arg.
has_default else '')
yield '{:<30} {}'.format(
cyan(' {} = ...,'.format(arg.name)),
' {}{}{}'.format(arg.description,
' ' if arg.description else '', default))
yield blue(')')
else:
for tti in extracter.get_target_type_info():
yield '{} {}'.format(cyan('{:>30}:'.format(tti.symbol)),
tti.description)
def test_get_function_args(self):
# Test standalone function.
def func(arg1, arg2, arg3=42, arg4=None, arg5='foo'):
pass
self.assertEqual([FunctionArg('arg1', '', False, None), FunctionArg('arg2', '', False, None),
FunctionArg('arg3', '', True, 42), FunctionArg('arg4', '', True, None),
FunctionArg('arg5', '', True, 'foo')],
BuildDictionaryInfoExtracter.get_function_args(func))
# Test member function.
class TestCls(object):
def __init__(self, arg1, arg2=False):
pass
self.assertEqual([FunctionArg('arg1', '', False, None), FunctionArg('arg2', '', True, False)],
BuildDictionaryInfoExtracter.get_function_args(TestCls.__init__))
# Test *args, **kwargs situation.
def generic_func(arg1, arg2=42, *args, **kwargs):
"""
:param arg1: The first arg.
:param arg2: The second arg.
:param args: Some extra varargs.
:param arg3: The third arg.
:param arg4: The fourth arg (default: 'Foo').
"""
self.assertEqual([FunctionArg('arg1', 'The first arg.', False, None),
FunctionArg('arg2', 'The second arg.', True, 42),
FunctionArg('*args', 'Some extra varargs.', False, None),
FunctionArg('arg3', 'The third arg.', True, None),
FunctionArg('arg4', "The fourth arg.", True, "'Foo'")],
BuildDictionaryInfoExtracter.get_function_args(generic_func))
def console_output(self, targets):
buildfile_aliases = self.context.build_configuration.registered_aliases(
)
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
alias = self.get_options().details
if alias:
tti = next(x for x in extracter.get_target_type_info()
if x.symbol == alias)
yield blue("\n{}\n".format(tti.description))
yield blue("{}(".format(alias))
for arg in tti.args:
default = green("(default: {})".format(arg.default) if arg.
has_default else "")
yield "{:<30} {}".format(
cyan(" {} = ...,".format(arg.name)),
" {}{}{}".format(arg.description,
" " if arg.description else "", default),
)
yield blue(")")
else:
for tti in extracter.get_target_type_info():
yield "{} {}".format(cyan("{:>30}:".format(tti.symbol)),
tti.description)
def test_get_target_type_info(self):
class Target1(Target):
"""Target1 docstring."""
pass
class Target2(Target):
"""Target2 docstring."""
pass
class Target3(Target):
"""Target3 docstring."""
pass
# We shouldn't get as far as invoking the context factory, so it can be trivial.
macro_factory = TargetMacro.Factory.wrap(lambda ctx: None, Target2)
bfa = BuildFileAliases(targets={
'target1': Target1,
'target2': macro_factory,
'target3': Target3,
},
objects={},
context_aware_object_factories={})
extracter = BuildDictionaryInfoExtracter(bfa)
args = BuildDictionaryInfoExtracter.basic_target_args
self.assertEqual([
BuildSymbolInfo('target1', 'Target1 docstring.', [], args),
BuildSymbolInfo('target2', 'Target2 docstring.', [], args),
BuildSymbolInfo('target3', 'Target3 docstring.', [], args)
], extracter.get_target_type_info())
def test_get_function_args(self):
# Test standalone function.
def func(arg1, arg2, arg3=42, arg4=None, arg5='foo'):
pass
self.assertEqual([FunctionArg('arg1', '', False, None), FunctionArg('arg2', '', False, None),
FunctionArg('arg3', '', True, 42), FunctionArg('arg4', '', True, None),
FunctionArg('arg5', '', True, 'foo')],
BuildDictionaryInfoExtracter.get_function_args(func))
# Test member function.
class TestCls(object):
def __init__(self, arg1, arg2=False):
pass
self.assertEqual([FunctionArg('arg1', '', False, None), FunctionArg('arg2', '', True, False)],
BuildDictionaryInfoExtracter.get_function_args(TestCls.__init__))
# Test *args, **kwargs situation.
def generic_func(arg1, arg2=42, *args, **kwargs):
"""
:param arg1: The first arg.
:param arg2: The second arg.
:param args: Some extra varargs.
:param arg3: The third arg.
:param arg4: The fourth arg (default: 'Foo').
"""
self.assertEqual([FunctionArg('arg1', 'The first arg.', False, None),
FunctionArg('arg2', 'The second arg.', True, 42),
FunctionArg('*args', 'Some extra varargs.', False, None),
FunctionArg('arg3', 'The third arg.', True, None),
FunctionArg('arg4', "The fourth arg.", True, "'Foo'")],
BuildDictionaryInfoExtracter.get_function_args(generic_func))
def test_get_target_args(self):
class Target1(Target):
def __init__(self, arg1, arg2=42, **kwargs):
"""
:param arg1: The first arg.
:param arg2: The second arg.
"""
super(Target1, self).__init__(**kwargs)
class Target2(Target1):
pass
class Target3(Target2):
def __init__(self, arg3, arg4=None, **kwargs):
super(Target1, self).__init__(**kwargs)
self.assertEqual(
sorted(BuildDictionaryInfoExtracter.basic_target_args + [
FunctionArg('arg1', 'The first arg.', False, None),
FunctionArg('arg2', 'The second arg.', True, 42),
FunctionArg('arg3', '', False, None),
FunctionArg('arg4', '', True, None)
]),
sorted(
BuildDictionaryInfoExtracter.get_args_for_target_type(
Target3)))
# Check a trivial case.
class Target4(Target):
pass
self.assertEqual(
BuildDictionaryInfoExtracter.basic_target_args,
BuildDictionaryInfoExtracter.get_args_for_target_type(Target4))
def test_get_object_factory_info(self):
class Foo:
"""Foo docstring."""
def __call__(self, bar, baz=42):
"""
:param bar: Bar details.
:param int baz: Baz details.
"""
bfa = BuildFileAliases(targets={},
objects={},
context_aware_object_factories={"foo": Foo})
extracter = BuildDictionaryInfoExtracter(bfa)
self.assertEqual(
[
BuildSymbolInfo(
"foo",
"Foo docstring.",
[],
[
FunctionArg("bar", "Bar details.", False, None),
FunctionArg("baz", "Baz details.", True, 42),
],
)
],
extracter.get_object_factory_info(),
)
def test_get_target_type_info(self):
class Target1(Target):
"""Target1 docstring."""
pass
class Target2(Target):
"""Target2 docstring."""
pass
class Target3(Target):
"""Target3 docstring."""
pass
# We shouldn't get as far as invoking the context factory, so it can be trivial.
macro_factory = TargetMacro.Factory.wrap(lambda ctx: None, Target2)
bfa = BuildFileAliases(targets={
'target1': Target1,
'target2': macro_factory,
'target3': Target3,
},
objects={},
context_aware_object_factories={}
)
extracter = BuildDictionaryInfoExtracter(bfa)
args = BuildDictionaryInfoExtracter.basic_target_args
self.assertEqual([BuildSymbolInfo('target1', 'Target1 docstring.', [], args),
BuildSymbolInfo('target2', 'Target2 docstring.', [], args),
BuildSymbolInfo('target3', 'Target3 docstring.', [], args)],
extracter.get_target_type_info())
def console_output(self, targets):
buildfile_aliases = self.context.build_file_parser.registered_aliases()
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
alias = self.get_options().details
if alias:
target_types = buildfile_aliases.target_types_by_alias.get(alias)
if target_types:
tti = next(x for x in extracter.get_target_type_info() if x.build_file_alias == alias)
yield blue('\n{}\n'.format(tti.description))
yield blue('{}('.format(alias))
for arg in extracter.get_target_args(list(target_types)[0]):
default = green('(default: {})'.format(arg.default) if arg.has_default else '')
yield '{:<30} {}'.format(
cyan(' {} = ...,'.format(arg.name)),
' {}{}{}'.format(arg.description, ' ' if arg.description else '', default))
yield blue(')')
else:
yield 'No such target type: {}'.format(alias)
else:
for tti in extracter.get_target_type_info():
description = tti.description or '<Add description>'
yield '{} {}'.format(cyan('{:>30}:'.format(tti.build_file_alias)), description)
def test_get_target_args(self):
class Target1(Target):
def __init__(self, arg1, arg2=42, **kwargs):
"""
:param arg1: The first arg.
:param arg2: The second arg.
"""
super(Target1, self).__init__(**kwargs)
class Target2(Target1):
pass
class Target3(Target2):
def __init__(self, arg3, arg4=None, **kwargs):
super(Target1, self).__init__(**kwargs)
self.assertEqual(sorted(BuildDictionaryInfoExtracter.basic_target_args + [
FunctionArg('arg1', 'The first arg.', False, None),
FunctionArg('arg2', 'The second arg.', True, 42),
FunctionArg('arg3', '', False, None),
FunctionArg('arg4', '', True, None)
]),
sorted(BuildDictionaryInfoExtracter.get_args_for_target_type(Target3)))
# Check a trivial case.
class Target4(Target):
pass
self.assertEqual(BuildDictionaryInfoExtracter.basic_target_args,
BuildDictionaryInfoExtracter.get_args_for_target_type(Target4))
def test_get_target_type_info(self):
class Target1(Target):
"""Target1 docstring."""
pass
class Target2a(Target):
# No docstring, so we should take the onefrom Target2b.
pass
class Target2b(Target):
"""Target2 docstring."""
pass
class Target3(Target):
"""Target3 docstring."""
pass
# We shouldn't get as far as invoking the context factory, so it can be trivial.
macro_factory = TargetMacro.Factory.wrap(lambda ctx: None, Target2a,
Target2b)
bfa = BuildFileAliases(targets={
'target1': Target1,
'target2': macro_factory,
'target3': Target3,
},
objects={},
context_aware_object_factories={})
extracter = BuildDictionaryInfoExtracter(bfa)
self.assertEquals([
TargetTypeInfo('target1', 'Target1 docstring.'),
TargetTypeInfo('target2', 'Target2 docstring.'),
TargetTypeInfo('target3', 'Target3 docstring.')
], extracter.get_target_type_info())
def test_get_target_type_info(self):
class Target1(Target):
"""Target1 docstring."""
pass
class Target2a(Target):
# No docstring, so we should take the onefrom Target2b.
pass
class Target2b(Target):
"""Target2 docstring."""
pass
class Target3(Target):
"""Target3 docstring."""
pass
# We shouldn't get as far as invoking the context factory, so it can be trivial.
macro_factory = TargetMacro.Factory.wrap(lambda ctx: None, Target2a, Target2b)
bfa = BuildFileAliases(targets={
'target1': Target1,
'target2': macro_factory,
'target3': Target3,
},
objects={},
context_aware_object_factories={}
)
extracter = BuildDictionaryInfoExtracter(bfa)
self.assertEquals([TargetTypeInfo('target1', 'Target1 docstring.'),
TargetTypeInfo('target2', 'Target2 docstring.'),
TargetTypeInfo('target3', 'Target3 docstring.')],
extracter.get_target_type_info())
def console_output(self, targets):
buildfile_aliases = self.context.build_file_parser.registered_aliases()
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
alias = self.get_options().details
if alias:
target_types = buildfile_aliases.target_types_by_alias.get(alias)
if target_types:
tti = next(x for x in extracter.get_target_type_info()
if x.build_file_alias == alias)
yield blue('\n{}\n'.format(tti.description))
yield blue('{}('.format(alias))
for arg in extracter.get_target_args(list(target_types)[0]):
default = green('(default: {})'.format(arg.default) if arg.
has_default else '')
yield '{:<30} {}'.format(
cyan(' {} = ...,'.format(arg.name)),
' {}{}{}'.format(arg.description,
' ' if arg.description else '',
default))
yield blue(')')
else:
yield 'No such target type: {}'.format(alias)
else:
for tti in extracter.get_target_type_info():
description = tti.description or '<Add description>'
yield '{} {}'.format(
cyan('{:>30}:'.format(tti.build_file_alias)), description)
def _gen_build_dictionary(self):
buildfile_aliases = self.context.build_file_parser.registered_aliases()
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
target_type_infos = extracter.get_target_type_info()
other_infos = sorted(extracter.get_object_info() + extracter.get_object_factory_info())
self._do_render(self.get_options().build_dictionary_template, {
'target_types': {
'infos': target_type_infos
},
'other_symbols': {
'infos': other_infos
}
})
def test_get_description_from_docstring(self):
class Test1(object):
"""First line.
Subsequent lines.
"""
self.assertEqual("First line.", BuildDictionaryInfoExtracter.get_description_from_docstring(Test1))
class Test2(object):
"""Only one line."""
self.assertEqual("Only one line.", BuildDictionaryInfoExtracter.get_description_from_docstring(Test2))
def test_get_function_args(self):
# Test standalone function.
def func(arg1, arg2, arg3=42, arg4=None, arg5="foo"):
pass
self.assertEqual(
[
FunctionArg("arg1", "", False, None),
FunctionArg("arg2", "", False, None),
FunctionArg("arg3", "", True, 42),
FunctionArg("arg4", "", True, None),
FunctionArg("arg5", "", True, "foo"),
],
BuildDictionaryInfoExtracter.get_function_args(func),
)
# Test member function.
class TestCls:
def __init__(self, arg1, arg2=False):
pass
self.assertEqual(
[
FunctionArg("arg1", "", False, None),
FunctionArg("arg2", "", True, False)
],
BuildDictionaryInfoExtracter.get_function_args(TestCls.__init__),
)
# Test *args, **kwargs situation.
def generic_func(arg1, arg2=42, *args, **kwargs):
"""
:param arg1: The first arg.
:param arg2: The second arg.
:param args: Some extra varargs.
:param arg3: The third arg.
:param arg4: The fourth arg (default: 'Foo').
"""
self.assertEqual(
[
FunctionArg("arg1", "The first arg.", False, None),
FunctionArg("arg2", "The second arg.", True, 42),
FunctionArg("*args", "Some extra varargs.", False, None),
FunctionArg("arg3", "The third arg.", True, None),
FunctionArg("arg4", "The fourth arg.", True, "'Foo'"),
],
BuildDictionaryInfoExtracter.get_function_args(generic_func),
)
def _gen_build_dictionary(self):
buildfile_aliases = self.context.build_configuration.registered_aliases()
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
target_type_infos = extracter.get_target_type_info()
other_infos = sorted(extracter.get_object_info() + extracter.get_object_factory_info())
build_dict_page = self._do_render(self.get_options().build_dictionary_template, {
'target_types': {
'infos': target_type_infos
},
'other_symbols': {
'infos': other_infos
}
})
self.context.products.register_data(self.BUILD_DICTIONARY_PRODUCT, build_dict_page)
def test_get_description_from_docstring(self):
class Test1(object):
"""First line.
Subsequent lines.
"""
self.assertEqual('First line.',
BuildDictionaryInfoExtracter.get_description_from_docstring(Test1))
class Test2(object):
"""Only one line."""
self.assertEqual('Only one line.',
BuildDictionaryInfoExtracter.get_description_from_docstring(Test2))
def _gen_build_dictionary(self):
buildfile_aliases = self.context.build_configuration.registered_aliases()
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
target_type_infos = extracter.get_target_type_info()
other_infos = sorted(extracter.get_object_info() + extracter.get_object_factory_info())
build_dict_page = self._do_render(self.get_options().build_dictionary_template, {
'target_types': {
'infos': target_type_infos
},
'other_symbols': {
'infos': other_infos
}
})
self.context.products.register_data(self.BUILD_DICTIONARY_PRODUCT, build_dict_page)
def _gen_build_dictionary(self):
buildfile_aliases = self.context.build_file_parser.registered_aliases()
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
target_type_infos = extracter.get_target_type_info()
other_infos = sorted(extracter.get_object_info() +
extracter.get_object_factory_info())
self._do_render(
self.get_options().build_dictionary_template, {
'target_types': {
'infos': target_type_infos
},
'other_symbols': {
'infos': other_infos
}
})
def test_get_multiline_arg_descriptions_from_docstring(self):
# Test multiline parameter descriptions, including where all help is on subsequent line.
def func(a, b, c, d, e):
"""Foo function.
:param a: Parameter a.
:param str b: Parameter b.
:param c: Parameter c
Second line Parameter c.
:param d:
Parameter d.
:param e: Parameter e.
"""
self.assertEqual(
{
"a": "Parameter a.",
"b": "Parameter b.",
"c": "Parameter c Second line Parameter c.",
"d": "Parameter d.",
"e": "Parameter e.",
},
BuildDictionaryInfoExtracter.get_arg_descriptions_from_docstring(
func),
)
def test_get_function_args(self):
# Test standalone function.
def func(arg1, arg2, arg3=42, arg4=None, arg5='foo'):
pass
self.assertEqual([FunctionArg('arg1', '', False, None), FunctionArg('arg2', '', False, None),
FunctionArg('arg3', '', True, 42), FunctionArg('arg4', '', True, None),
FunctionArg('arg5', '', True, 'foo')],
BuildDictionaryInfoExtracter.get_function_args(func))
# Test member function.
class TestCls(object):
def __init__(self, arg1, arg2=False):
pass
self.assertEqual([FunctionArg('arg1', '', False, None), FunctionArg('arg2', '', True, False)],
BuildDictionaryInfoExtracter.get_function_args(TestCls.__init__))
def test_get_object_factory_info(self):
class Foo(object):
"""Foo docstring."""
def __call__(self, bar, baz=42):
"""
:param bar: Bar details.
:param int baz: Baz details.
"""
bfa = BuildFileAliases(targets={},
objects={},
context_aware_object_factories={'foo': Foo})
extracter = BuildDictionaryInfoExtracter(bfa)
self.assertEquals([
BuildSymbolInfo('foo', 'Foo docstring.', [], [
FunctionArg('bar', 'Bar details.', False, None),
FunctionArg('baz', 'Baz details.', True, 42)
])
], extracter.get_object_factory_info())
def test_get_description_from_docstring(self):
class Test1(object):
"""First line.
Subsequent
lines.
with indentations
"""
self.assertEqual(('First line.', ['Subsequent', 'lines.', '', ' with indentations']),
BuildDictionaryInfoExtracter.get_description_from_docstring(Test1))
class Test2(object):
"""Only one line."""
self.assertEqual(('Only one line.', []),
BuildDictionaryInfoExtracter.get_description_from_docstring(Test2))
def test_get_description_from_docstring(self):
class Test1(object):
"""First line.
Subsequent
lines.
with indentations
"""
self.assertEqual(('First line.', ['Subsequent', 'lines.', '', ' with indentations']),
BuildDictionaryInfoExtracter.get_description_from_docstring(Test1))
class Test2(object):
"""Only one line."""
self.assertEqual(('Only one line.', []),
BuildDictionaryInfoExtracter.get_description_from_docstring(Test2))
def console_output(self, targets):
buildfile_aliases = self.context.build_file_parser.registered_aliases()
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
alias = self.get_options().details
if alias:
tti = next(x for x in extracter.get_target_type_info() if x.symbol == alias)
yield blue('\n{}\n'.format(tti.description))
yield blue('{}('.format(alias))
for arg in tti.args:
default = green('(default: {})'.format(arg.default) if arg.has_default else '')
yield '{:<30} {}'.format(
cyan(' {} = ...,'.format(arg.name)),
' {}{}{}'.format(arg.description, ' ' if arg.description else '', default))
yield blue(')')
else:
for tti in extracter.get_target_type_info():
yield '{} {}'.format(cyan('{:>30}:'.format(tti.symbol)), tti.description)
def test_get_arg_descriptions_from_docstring(self):
def func(a, b, c):
"""Foo function.
:param a: Parameter a.
:param str b: Parameter b.
:param c: Parameter c.
"""
self.assertEqual({'a': 'Parameter a.', 'b': 'Parameter b.', 'c': 'Parameter c.'},
BuildDictionaryInfoExtracter.get_arg_descriptions_from_docstring(func))
def test_get_arg_descriptions_from_docstring(self):
def func(a, b, c):
"""Foo function.
:param a: Parameter a.
:param str b: Parameter b.
:param c: Parameter c.
"""
self.assertEqual({'a': 'Parameter a.', 'b': 'Parameter b.', 'c': 'Parameter c.'},
BuildDictionaryInfoExtracter.get_arg_descriptions_from_docstring(func))
def test_get_object_factory_info(self):
class Foo(object):
"""Foo docstring."""
def __call__(self, bar, baz=42):
"""
:param bar: Bar details.
:param int baz: Baz details.
"""
bfa = BuildFileAliases(targets={},
objects={},
context_aware_object_factories={
'foo': Foo
}
)
extracter = BuildDictionaryInfoExtracter(bfa)
self.assertEqual([BuildSymbolInfo('foo', 'Foo docstring.', [],
[FunctionArg('bar', 'Bar details.', False, None),
FunctionArg('baz', 'Baz details.', True, 42)])],
extracter.get_object_factory_info())
def test_get_object_info(self):
class Foo(object):
"""Foo docstring."""
def __init__(self, bar, baz=42):
"""
:param bar: Bar details.
:param int baz: Baz details.
"""
bfa = BuildFileAliases(targets={}, objects={"foo": Foo}, context_aware_object_factories={})
extracter = BuildDictionaryInfoExtracter(bfa)
self.assertEquals(
[
BuildSymbolInfo(
"foo",
"Foo docstring.",
[FunctionArg("bar", "Bar details.", False, None), FunctionArg("baz", "Baz details.", True, 42)],
)
],
extracter.get_object_info(),
)
def test_get_target_type_info(self):
class Target1(Target):
"""Target1 docstring."""
pass
class Target2a(Target):
# No docstring, so we should take the one from Target2b.
pass
class Target2b(Target):
"""Target2 docstring."""
pass
class Target3(Target):
"""Target3 docstring."""
pass
# We shouldn't get as far as invoking the context factory, so it can be trivial.
macro_factory = TargetMacro.Factory.wrap(lambda ctx: None, Target2a, Target2b)
bfa = BuildFileAliases(
targets={"target1": Target1, "target2": macro_factory, "target3": Target3},
objects={},
context_aware_object_factories={},
)
extracter = BuildDictionaryInfoExtracter(bfa)
args = BuildDictionaryInfoExtracter.basic_target_args
self.assertEquals(
[
BuildSymbolInfo("target1", "Target1 docstring.", args),
BuildSymbolInfo("target2", "Target2 docstring.", args),
BuildSymbolInfo("target3", "Target3 docstring.", args),
],
extracter.get_target_type_info(),
)
def test_get_arg_descriptions_from_docstring(self):
def func(a, b, c):
"""Foo function.
:param a: Parameter a.
:param str b: Parameter b.
:param c: Parameter c.
"""
self.assertEqual(
{"a": "Parameter a.", "b": "Parameter b.", "c": "Parameter c."},
BuildDictionaryInfoExtracter.get_arg_descriptions_from_docstring(func),
)
def test_get_object_info_datatype(self):
class FooDatatype(datatype(['bar', 'baz'])):
"""Foo docstring."""
def __new__(cls, bar, baz=42):
"""
:param bar: Bar details.
:param int baz: Baz details.
"""
return super(FooDatatype, cls).__new__(cls, bar, baz)
bfa = BuildFileAliases(
targets={},
objects={'foo': FooDatatype},
context_aware_object_factories={},
)
extracter = BuildDictionaryInfoExtracter(bfa)
self.assertEquals([
BuildSymbolInfo('foo', 'Foo docstring.', [], [
FunctionArg('bar', 'Bar details.', False, None),
FunctionArg('baz', 'Baz details.', True, 42)
])
], extracter.get_object_info())
def test_get_function_args(self):
# Test standalone function.
def func(arg1, arg2, arg3=42, arg4=None, arg5='foo'):
pass
self.assertEqual([
FunctionArg('arg1', '', False, None),
FunctionArg('arg2', '', False, None),
FunctionArg('arg3', '', True, 42),
FunctionArg('arg4', '', True, None),
FunctionArg('arg5', '', True, 'foo')
], BuildDictionaryInfoExtracter.get_function_args(func))
# Test member function.
class TestCls(object):
def __init__(self, arg1, arg2=False):
pass
self.assertEqual([
FunctionArg('arg1', '', False, None),
FunctionArg('arg2', '', True, False)
], BuildDictionaryInfoExtracter.get_function_args(TestCls.__init__))
def test_get_object_info_datatype(self):
class FooDatatype(datatype(['bar', 'baz'])):
"""Foo docstring."""
def __new__(cls, bar, baz=42):
"""
:param bar: Bar details.
:param int baz: Baz details.
"""
return super(FooDatatype, cls).__new__(cls, bar, baz)
bfa = BuildFileAliases(targets={},
objects={
'foo': FooDatatype
},
context_aware_object_factories={},
)
extracter = BuildDictionaryInfoExtracter(bfa)
self.assertEqual([BuildSymbolInfo('foo', 'Foo docstring.', [],
[FunctionArg('bar', 'Bar details.', False, None),
FunctionArg('baz', 'Baz details.', True, 42)])],
extracter.get_object_info())
def test_get_object_info_datatype(self):
class FooDatatype(datatype("FooDatatype", ["bar", "baz"])):
"""Foo docstring."""
def __new__(cls, bar, baz=42):
"""
:param bar: Bar details.
:param int baz: Baz details.
"""
return super(Foo, cls).__new__(cls, bar, baz)
bfa = BuildFileAliases(targets={}, objects={"foo": FooDatatype}, context_aware_object_factories={})
extracter = BuildDictionaryInfoExtracter(bfa)
self.assertEquals(
[
BuildSymbolInfo(
"foo",
"Foo docstring.",
[FunctionArg("bar", "Bar details.", False, None), FunctionArg("baz", "Baz details.", True, 42)],
)
],
extracter.get_object_info(),
)
def test_get_description_from_docstring(self):
class Test1(object):
"""First line.
Subsequent
lines.
with indentations
"""
self.assertEqual(
("First line.",
["Subsequent", "lines.", "", " with indentations"]),
BuildDictionaryInfoExtracter.get_description_from_docstring(Test1),
)
class Test2(object):
"""Only one line."""
self.assertEqual(
("Only one line.", []),
BuildDictionaryInfoExtracter.get_description_from_docstring(Test2),
)
def test_get_arg_descriptions_with_nonparams_from_docstring(self):
# Test parameter help where help for items other than parameters is present.
def func(a, b, c):
"""Foo function.
:param a: Parameter a.
:type j: Type j.
:type k: Type k.
Second line Type k.
:param str b: Parameter b.
:param c: Parameter c.
:returns: Return.
"""
self.assertEqual({'a': 'Parameter a.', 'b': 'Parameter b.', 'c': 'Parameter c.'},
BuildDictionaryInfoExtracter.get_arg_descriptions_from_docstring(func))
def test_get_arg_descriptions_with_nonparams_from_docstring(self):
# Test parameter help where help for items other than parameters is present.
def func(a, b, c):
"""Foo function.
:param a: Parameter a.
:type j: Type j.
:type k: Type k.
Second line Type k.
:param str b: Parameter b.
:param c: Parameter c.
:returns: Return.
"""
self.assertEqual({'a': 'Parameter a.', 'b': 'Parameter b.', 'c': 'Parameter c.'},
BuildDictionaryInfoExtracter.get_arg_descriptions_from_docstring(func))
def test_get_multiline_arg_descriptions_from_docstring(self):
# Test multiline parameter descriptions, including where all help is on subsequent line.
def func(a, b, c, d, e):
"""Foo function.
:param a: Parameter a.
:param str b: Parameter b.
:param c: Parameter c
Second line Parameter c.
:param d:
Parameter d.
:param e: Parameter e.
"""
self.assertEqual({'a': 'Parameter a.', 'b': 'Parameter b.',
'c': 'Parameter c Second line Parameter c.',
'd': 'Parameter d.', 'e': 'Parameter e.'},
BuildDictionaryInfoExtracter.get_arg_descriptions_from_docstring(func))
def test_get_arg_descriptions_from_docstring(self):
def func(a, b, c):
"""Foo function.
:param a: Parameter a.
:param str b: Parameter b.
:param c: Parameter c.
"""
self.assertEqual(
{
"a": "Parameter a.",
"b": "Parameter b.",
"c": "Parameter c."
},
BuildDictionaryInfoExtracter.get_arg_descriptions_from_docstring(
func),
)
def test_get_target_args(self):
class Target1(Target):
def __init__(self, arg1, arg2=42, **kwargs):
"""
:param arg1: The first arg.
:param arg2: The second arg.
"""
super(Target1, self).__init__(**kwargs)
class Target2(Target1):
pass
class Target3(Target2):
def __init__(self, arg3, arg4=None, **kwargs):
super(Target1, self).__init__(**kwargs)
self.maxDiff = None
self.assertEqual(BuildDictionaryInfoExtracter.basic_target_args + [
FunctionArg('arg1', 'The first arg.', False, None),
FunctionArg('arg2', 'The second arg.', True, 42),
FunctionArg('arg3', '', False, None),
FunctionArg('arg4', '', True, None)
],
BuildDictionaryInfoExtracter.get_target_args(Target3))
def test_get_target_args(self):
class Target1(Target):
def __init__(self, arg1, arg2=42, **kwargs):
"""
:param arg1: The first arg.
:param arg2: The second arg.
"""
super(Target1, self).__init__(**kwargs)
class Target2(Target1):
pass
class Target3(Target2):
def __init__(self, arg3, arg4=None, **kwargs):
super(Target1, self).__init__(**kwargs)
self.maxDiff = None
self.assertEqual(
BuildDictionaryInfoExtracter.basic_target_args + [
FunctionArg('arg1', 'The first arg.', False, None),
FunctionArg('arg2', 'The second arg.', True, 42),
FunctionArg('arg3', '', False, None),
FunctionArg('arg4', '', True, None)
], BuildDictionaryInfoExtracter.get_target_args(Target3))
def _target_types(self):
buildfile_aliases = self.context.build_configuration.registered_aliases(
)
extracter = BuildDictionaryInfoExtracter(buildfile_aliases)
return [x.symbol for x in extracter.get_target_type_info()]
