def test_from_function(self):
uut = FunctionMetadata.from_function(self.test_from_function)
self.check_function_metadata_data_set(uut, "test_from_function")
uut = FunctionMetadata.from_function(TestClass(5, 5).__init__)
self.check_function_metadata_data_set(uut,
"__init__",
desc="Description",
retval_desc="ret",
non_optional_params={
"param1": (uut.str_nodesc, None),
"param2": ("d", None)
},
optional_params={
"param3": (uut.str_nodesc + " (" + uut.str_optional.format("5") + ")",
None, 5),
"param4": ("p4 desc (" + uut.str_optional.format("6") + ")", int, 6)
})
uut = FunctionMetadata.from_function(TestClass(5, 5).__init__, omit=["param3", "param2"])
self.check_function_metadata_data_set(uut,
"__init__",
desc="Description",
retval_desc="ret",
non_optional_params={
"param1": (uut.str_nodesc, None)
},
optional_params={
"param4": ("p4 desc (" + uut.str_optional.format("6") + ")", int, 6)
})
def get_metadata(cls):
return FunctionMetadata.merge(
FunctionMetadata.from_function(
cls.run,
omit={"self", "dependency_results"}),
cls.get_shortlog_checks_metadata(),
cls.get_body_checks_metadata())
def run(self, filename, file, **kwargs):
# Get the **kwargs params to forward to `generate_config()`
# (from `_create_config()`).
generate_config_kwargs = FunctionMetadata.filter_parameters(
self._get_generate_config_metadata(), kwargs)
with self._create_config(
filename,
file,
**generate_config_kwargs) as config_file:
# And now retrieve the **kwargs for `create_arguments()`.
create_arguments_kwargs = (
FunctionMetadata.filter_parameters(
self._get_create_arguments_metadata(), kwargs))
arguments = (self.get_executable(),) + tuple(
self.create_arguments(
filename, file, config_file,
**create_arguments_kwargs))
self.debug("Running '{}'".format(' '.join(arguments)))
output = run_shell_command(
arguments,
stdin="".join(file) if options["use_stdin"] else None)
output = tuple(compress(
output,
(options["use_stdout"], options["use_stderr"])))
if len(output) == 1:
output = output[0]
process_output_kwargs = FunctionMetadata.filter_parameters(
self._get_process_output_metadata(), kwargs)
return self.process_output(output, filename, file,
**process_output_kwargs)
def get_metadata(cls):
metadata = FunctionMetadata(
'run',
optional_params=cls.get_optional_params(),
non_optional_params=cls.get_non_optional_params())
metadata.desc = inspect.getdoc(cls)
return metadata
def get_metadata(cls):
return FunctionMetadata.merge(
FunctionMetadata.from_function(
cls.run,
omit={'self', 'dependency_results'}),
cls.get_shortlog_checks_metadata(),
cls.get_body_checks_metadata(),
cls.get_issue_checks_metadata())
def test_add_deprecated_param(self):
uut = FunctionMetadata(
'test',
non_optional_params={'not_optional': ('desc', str)},
optional_params={'optional': ('desc2', str, 'default')})
uut.add_deprecated_param('optional', 'old_optional')
uut.add_deprecated_param('not_optional', 'old_not_optional')
self.assertEqual(uut.non_optional_params,
{'not_optional': ('desc', str)})
self.assertEqual(uut.optional_params,
{'optional': ('desc2', str, 'default'),
'old_optional': ('desc2', str, 'default'),
'old_not_optional': ('desc', str, None)})
def _func_decorator(func):
@wraps(func)
def _new_func(self, *args, **kwargs):
if not self.section.aspects:
return func(self, *args, **kwargs)
aspects = self.section.aspects
for arg, aspect_value in aspectable_settings.items():
# Explicit bear setting takes priority over aspects
if arg in self.section:
continue
taste, aspect_settings = aspect_value
aspect_instance = aspects.get(taste.aspect_name)
if aspect_instance:
value = aspect_instance.tastes[taste.name]
for value_pair in aspect_value[1]:
if value_pair[0] == value:
kwargs[arg] = value_pair[1]
return func(self, *args, **kwargs)
# Keep metadata
_new_func.__metadata__ = FunctionMetadata.from_function(func)
return _new_func
def _deprecate_decorator(func):
def wrapping_function(*args, **kwargs):
for arg, depr_arg_and_modifier in depr_args.items():
deprecated_arg, _func = (
depr_arg_and_modifier
if isinstance(depr_arg_and_modifier, tuple)
else (depr_arg_and_modifier, lambda x: x))
if deprecated_arg in kwargs:
print("The setting `{}` is deprecated. Please use `{}` "
"instead.".format(deprecated_arg, arg))
depr_arg_value = _func.__call__(kwargs[deprecated_arg])
if arg in kwargs and depr_arg_value != kwargs[arg]:
print('The value of `{}` and `{}` are conflicting.'
' `{}` will be used instead.'.format(
deprecated_arg, arg, arg))
else:
kwargs[arg] = depr_arg_value
del kwargs[deprecated_arg]
return func(*args, **kwargs)
new_metadata = FunctionMetadata.from_function(func)
for arg, depr_arg_and_modifier in depr_args.items():
deprecated_arg = (depr_arg_and_modifier[0]
if isinstance(depr_arg_and_modifier, tuple)
else depr_arg_and_modifier)
new_metadata.add_alias(arg, deprecated_arg)
wrapping_function.__metadata__ = new_metadata
return wrapping_function
def get_metadata(cls):
merged_metadata = FunctionMetadata.merge(
cls._get_process_output_metadata(),
cls._get_generate_config_metadata(),
cls._get_create_arguments_metadata())
merged_metadata.desc = inspect.getdoc(cls)
return merged_metadata
def test_create_params_from_section_invalid(self):
section = Section("name")
section.append(Setting("bad_param", "value"))
uut = FunctionMetadata.from_function(TestClass(5, 5).bad_function)
with self.assertRaises(ValueError):
uut.create_params_from_section(section)
def get_metadata(cls):
"""
:return: Metadata for the run function. However parameters like
``self`` or parameters implicitly used by coala (e.g.
filename for local bears) are already removed.
"""
return FunctionMetadata.from_function(cls.run, omit={"self", "dependency_results"})
def test_merge(self):
metadata1 = FunctionMetadata(
"main",
"Desc of main.\n",
"Returns 0 on success",
{"argc": ("argc desc", None), "argv": ("argv desc", None)},
{"opt": ("opt desc", int, 88)},
{"self", "A"},
{"test1"})
metadata2 = FunctionMetadata(
"process",
"Desc of process.\n",
"Returns the processed stuff.",
{"argc": ("argc desc from process", int),
"to_process": ("to_process desc", int)},
{"opt2": ("opt2 desc", str, "hello")},
{"self", "B"},
{"test2"})
metadata3 = FunctionMetadata("nodesc", "", "", {}, {})
merged_metadata = FunctionMetadata.merge(metadata1,
metadata2,
metadata3)
self.assertEqual(
merged_metadata.name,
"<Merged signature of 'main', 'process', 'nodesc'>")
self.assertEqual(merged_metadata.desc, "Desc of process.\n")
self.assertEqual(merged_metadata.retval_desc,
"Returns the processed stuff.")
self.assertEqual(
merged_metadata.non_optional_params,
{"argc": ("argc desc from process", int),
"argv": ("argv desc", None),
"to_process": ("to_process desc", int)})
self.assertEqual(
merged_metadata.optional_params,
{"opt": ("opt desc", int, 88),
"opt2": ("opt2 desc", str, "hello")})
self.assertEqual(
merged_metadata.omit,
frozenset({"self", "A", "B"}))
self.assertEqual(
merged_metadata.deprecated_params,
frozenset({"test1", "test2"}))
def get_metadata(cls):
"""
:return: Metadata for the run function. However parameters like
``self`` or parameters implicitly used by coala (e.g.
filename for local bears) are already removed.
"""
return FunctionMetadata.from_function(
cls.run, omit={'self', 'dependency_results'})
def get_metadata(cls):
"""
:return:
Metadata for the ``analyze`` function extracted from its signature.
Excludes parameters ``self`` and ``files``.
"""
return FunctionMetadata.from_function(cls.analyze,
omit={'self', 'files'})
def get_metadata(cls):
"""
:return:
Metadata for the ``analyze`` function extracted from its signature.
Excludes parameters ``self``, ``filename`` and ``file``.
"""
return FunctionMetadata.from_function(
cls.analyze, omit={'self', 'dependency_bear', 'dependency_result'})
def test_construction(self):
self.assertRaises(TypeError, FunctionMetadata, 5)
self.assertRaises(TypeError, FunctionMetadata, "name", desc=5)
self.assertRaises(TypeError, FunctionMetadata, "name", retval_desc=5)
self.assertRaises(TypeError, FunctionMetadata, "name", non_optional_params=5)
self.assertRaises(TypeError, FunctionMetadata, "name", optional_params=5)
self.assertRaises(TypeError, FunctionMetadata.from_function, 5)
self.assertRaises(TypeError, FunctionMetadata.from_function, self.test_construction, 5)
self.check_function_metadata_data_set(FunctionMetadata("name"), "name")
def get_metadata(cls):
"""
:return:
Metadata for the ``analyze`` function extracted from its signature.
Excludes parameters ``self``, ``filename`` and ``file``.
"""
return FunctionMetadata.from_function(
cls.analyze,
omit={'self', 'filename', 'file'})
def _deprecate_decorator(func):
logged_deprecated_args = set()
@wraps(func)
def wrapping_function(*args, **kwargs):
for arg, depr_value in wrapping_function.__metadata__.depr_values:
deprecated_arg = depr_value[0]
_func = depr_value[1]
if deprecated_arg in kwargs:
if deprecated_arg not in logged_deprecated_args:
logging.warning(
'The setting `{}` is deprecated. Please use `{}` '
'instead.'.format(deprecated_arg, arg))
logged_deprecated_args.add(deprecated_arg)
depr_arg_value = _func.__call__(kwargs[deprecated_arg])
if arg in kwargs and depr_arg_value != kwargs[arg]:
logging.warning(
'The value of `{}` and `{}` are conflicting.'
' `{}` will be used instead.'.format(
deprecated_arg, arg, arg))
else:
kwargs[arg] = depr_arg_value
del kwargs[deprecated_arg]
return func(*args, **kwargs)
new_metadata = FunctionMetadata.from_function(func)
new_metadata.depr_values = []
for arg, depr_values in depr_args.items():
if not isinstance(depr_values, tuple):
depr_values = (depr_values,)
if callable(depr_values[-1]):
deprecated_args = depr_values[:-1]
default_modifier = depr_values[-1]
else:
deprecated_args = depr_values
default_modifier = _do_nothing
for depr_value in deprecated_args:
if isinstance(depr_value, dict):
deprecated_arg = list(depr_value.keys())[0]
modifier = depr_value[deprecated_arg]
new_metadata.depr_values.append((arg,
(deprecated_arg,
modifier)))
else:
deprecated_arg = depr_value
new_metadata.depr_values.append((arg,
(deprecated_arg,
default_modifier)))
new_metadata.add_deprecated_param(arg, deprecated_arg)
wrapping_function.__metadata__ = new_metadata
return wrapping_function
def run(self, filename, file, **kwargs):
# Get the **kwargs params to forward to `generate_config()`
# (from `_create_config()`).
generate_config_kwargs = FunctionMetadata.filter_parameters(
self._get_generate_config_metadata(), kwargs)
with self._create_config(
filename,
file,
**generate_config_kwargs) as config_file:
# And now retrieve the **kwargs for `create_arguments()`.
create_arguments_kwargs = (
FunctionMetadata.filter_parameters(
self._get_create_arguments_metadata(), kwargs))
args = self.create_arguments(filename, file, config_file,
**create_arguments_kwargs)
try:
args = tuple(args)
except TypeError:
self.err('The given arguments '
'{!r} are not iterable.'.format(args))
return
arguments = (self.get_executable(),) + args
self.debug("Running '{}'".format(' '.join(arguments)))
output = run_shell_command(
arguments,
stdin=''.join(file) if options['use_stdin'] else None,
cwd=self.get_config_dir())
output = tuple(compress(
output,
(options['use_stdout'], options['use_stderr'])))
if len(output) == 1:
output = output[0]
process_output_kwargs = FunctionMetadata.filter_parameters(
self._get_process_output_metadata(), kwargs)
return self.process_output(output, filename, file,
**process_output_kwargs)
def get_metadata(cls):
merged_metadata = FunctionMetadata.merge(
cls._get_process_output_metadata(),
cls._get_generate_config_metadata(),
cls._get_create_arguments_metadata())
merged_metadata.desc = (
"{}\n\nThis bear uses the {!r} tool.".format(
inspect.getdoc(cls), cls.get_executable()))
return merged_metadata
def run(self, filename, file, **kwargs):
# Get the **kwargs params to forward to `generate_config()`
# (from `_create_config()`).
generate_config_kwargs = FunctionMetadata.filter_parameters(
self._get_generate_config_metadata(), kwargs)
with self._create_config(
filename,
file,
**generate_config_kwargs) as config_file:
# And now retrieve the **kwargs for `create_arguments()`.
create_arguments_kwargs = (
FunctionMetadata.filter_parameters(
self._get_create_arguments_metadata(), kwargs))
args = self.create_arguments(filename, file, config_file,
**create_arguments_kwargs)
try:
args = tuple(args)
except TypeError:
self.err("The given arguments "
"{!r} are not iterable.".format(args))
return
arguments = (self.get_executable(),) + args
self.debug("Running '{}'".format(' '.join(arguments)))
output = run_shell_command(
arguments,
stdin="".join(file) if options["use_stdin"] else None,
cwd=self.get_config_dir())
output = tuple(compress(
output,
(options["use_stdout"], options["use_stderr"])))
if len(output) == 1:
output = output[0]
process_output_kwargs = FunctionMetadata.filter_parameters(
self._get_process_output_metadata(), kwargs)
return self.process_output(output, filename, file,
**process_output_kwargs)
def get_metadata(cls):
merged_metadata = FunctionMetadata.merge(
cls._get_process_output_metadata(),
cls._get_generate_config_metadata(),
cls._get_create_arguments_metadata())
merged_metadata.desc = (
"{}\n\nThis bear uses the {!r} tool.".format(
inspect.getdoc(cls), cls.get_executable()))
return merged_metadata
def test_from_function(self):
uut = FunctionMetadata.from_function(self.test_from_function)
self.check_function_metadata_data_set(uut, "test_from_function")
# setattr on bound methods will fail, vars() will use the dict from
# the unbound method which is ok.
vars(self.test_from_function)["__metadata__"] = (
FunctionMetadata("t"))
uut = FunctionMetadata.from_function(self.test_from_function)
self.check_function_metadata_data_set(uut, "t")
uut = FunctionMetadata.from_function(TestClass(5, 5).__init__)
self.check_function_metadata_data_set(
uut,
"__init__",
desc="Description",
retval_desc="ret",
non_optional_params={
"param1": (uut.str_nodesc, None),
"param2": ("d", None)
},
optional_params={
"param3": (uut.str_nodesc + " ("
+ uut.str_optional.format("5") + ")",
None, 5),
"param4": ("p4 desc ("
+ uut.str_optional.format("6") + ")", int, 6)})
uut = FunctionMetadata.from_function(TestClass(5, 5).__init__,
omit={"param3", "param2"})
self.check_function_metadata_data_set(
uut,
"__init__",
desc="Description",
retval_desc="ret",
non_optional_params={
"param1": (uut.str_nodesc,
None)
},
optional_params={
"param4": ("p4 desc (" + uut.str_optional.format("6") + ")",
int,
6)})
def test_from_function(self):
uut = FunctionMetadata.from_function(self.test_from_function)
self.check_function_metadata_data_set(uut, 'test_from_function')
# setattr on bound methods will fail, vars() will use the dict from
# the unbound method which is ok.
vars(self.test_from_function)['__metadata__'] = (
FunctionMetadata('t'))
uut = FunctionMetadata.from_function(self.test_from_function)
self.check_function_metadata_data_set(uut, 't')
uut = FunctionMetadata.from_function(TestClass(5, 5).__init__)
self.check_function_metadata_data_set(
uut,
'__init__',
desc='Description',
retval_desc='ret',
non_optional_params={
'param1': (uut.str_nodesc, None),
'param2': ('d', None)
},
optional_params={
'param3': (uut.str_nodesc + ' ('
+ uut.str_optional.format('5') + ')',
None, 5),
'param4': ('p4 desc ('
+ uut.str_optional.format('6') + ')', int, 6)})
uut = FunctionMetadata.from_function(TestClass(5, 5).__init__,
omit={'param3', 'param2'})
self.check_function_metadata_data_set(
uut,
'__init__',
desc='Description',
retval_desc='ret',
non_optional_params={
'param1': (uut.str_nodesc,
None)
},
optional_params={
'param4': ('p4 desc (' + uut.str_optional.format('6') + ')',
int,
6)})
def test_from_function(self):
uut = FunctionMetadata.from_function(self.test_from_function)
self.check_function_metadata_data_set(uut, "test_from_function")
# setattr on bound methods will fail, __dict__ will use the dict from
# the unbound method which is ok.
self.test_from_function.__dict__["__metadata__"] = (
FunctionMetadata("t"))
uut = FunctionMetadata.from_function(self.test_from_function)
self.check_function_metadata_data_set(uut, "t")
uut = FunctionMetadata.from_function(TestClass(5, 5).__init__)
self.check_function_metadata_data_set(
uut,
"__init__",
desc="Description",
retval_desc="ret",
non_optional_params={
"param1": (uut.str_nodesc, None),
"param2": ("d", None)
},
optional_params={
"param3": (uut.str_nodesc + " ("
+ uut.str_optional.format("5") + ")",
None, 5),
"param4": ("p4 desc ("
+ uut.str_optional.format("6") + ")", int, 6)})
uut = FunctionMetadata.from_function(TestClass(5, 5).__init__,
omit={"param3", "param2"})
self.check_function_metadata_data_set(
uut,
"__init__",
desc="Description",
retval_desc="ret",
non_optional_params={
"param1": (uut.str_nodesc,
None)
},
optional_params={
"param4": ("p4 desc (" + uut.str_optional.format("6") + ")",
int,
6)})
def test_create_params_from_section_valid(self):
section = Section("name")
section.append(Setting("a_param", "value"))
uut = FunctionMetadata.from_function(TestClass(5, 5).good_function)
with self.assertRaises(ValueError):
uut.create_params_from_section(section)
section.append(Setting("a_param", "5"))
params = uut.create_params_from_section(section)
self.assertEqual(params['a_param'], 5)
def test_from_function(self):
uut = FunctionMetadata.from_function(self.test_from_function)
self.check_function_metadata_data_set(uut, 'test_from_function')
# setattr on bound methods will fail, vars() will use the dict from
# the unbound method which is ok.
vars(self.test_from_function)['__metadata__'] = (FunctionMetadata('t'))
uut = FunctionMetadata.from_function(self.test_from_function)
self.check_function_metadata_data_set(uut, 't')
uut = FunctionMetadata.from_function(TestClass(5, 5).__init__)
self.check_function_metadata_data_set(
uut,
'__init__',
desc='Description',
retval_desc='ret',
non_optional_params={
'param1': (uut.str_nodesc, None),
'param2': ('d', None)
},
optional_params={
'param3':
(uut.str_nodesc + ' (' + uut.str_optional.format('5') + ')',
None, 5),
'param4':
('p4 desc (' + uut.str_optional.format('6') + ')', int, 6)
})
uut = FunctionMetadata.from_function(TestClass(5, 5).__init__,
omit={'param3', 'param2'})
self.check_function_metadata_data_set(
uut,
'__init__',
desc='Description',
retval_desc='ret',
non_optional_params={'param1': (uut.str_nodesc, None)},
optional_params={
'param4':
('p4 desc (' + uut.str_optional.format('6') + ')', int, 6)
})
def _get_process_output_metadata(cls):
metadata = FunctionMetadata.from_function(cls.process_output)
if options['output_format'] is None:
omitted = {'self', 'output', 'filename', 'file'}
else:
# If a specific output format is provided, function signatures
# from process_output functions should not appear in the help.
omitted = set(chain(metadata.non_optional_params,
metadata.optional_params))
metadata.omit = omitted
return metadata
def _get_process_output_metadata(cls):
metadata = FunctionMetadata.from_function(cls.process_output)
if options["output_format"] is None:
omitted = {"self", "output", "filename", "file"}
else:
# If a specific output format is provided, function signatures
# from process_output functions should not appear in the help.
omitted = set(chain(metadata.non_optional_params,
metadata.optional_params))
metadata.omit = omitted
return metadata
def get_metadata(cls):
"""
Retrieves metadata for the apply function. The description may be used to advertise this action to the user.
The parameters and their help texts are additional information that are needed from the user. You can create a
section out of the inputs from the user and use apply_from_section to apply
:return A FunctionMetadata object.
"""
data = FunctionMetadata.from_function(
cls.apply,
omit=["self", "result", "original_file_dict", "file_diff_dict"])
data.name = cls.__name__
return data
def test_merge(self):
metadata1 = FunctionMetadata('main', 'Desc of main.\n',
'Returns 0 on success', {
'argc': ('argc desc', None),
'argv': ('argv desc', None)
}, {'opt': ('opt desc', int, 88)},
{'self', 'A'}, {'test1'})
metadata2 = FunctionMetadata(
'process', 'Desc of process.\n', 'Returns the processed stuff.', {
'argc': ('argc desc from process', int),
'to_process': ('to_process desc', int)
}, {'opt2': ('opt2 desc', str, 'hello')}, {'self', 'B'}, {'test2'})
metadata3 = FunctionMetadata('nodesc', '', '', {}, {})
merged_metadata = FunctionMetadata.merge(metadata1, metadata2,
metadata3)
self.assertEqual(merged_metadata.name,
"<Merged signature of 'main', 'process', 'nodesc'>")
self.assertEqual(merged_metadata.desc, 'Desc of process.\n')
self.assertEqual(merged_metadata.retval_desc,
'Returns the processed stuff.')
self.assertEqual(
merged_metadata.non_optional_params, {
'argc': ('argc desc from process', int),
'argv': ('argv desc', None),
'to_process': ('to_process desc', int)
})
self.assertEqual(merged_metadata.optional_params, {
'opt': ('opt desc', int, 88),
'opt2': ('opt2 desc', str, 'hello')
})
self.assertEqual(merged_metadata.omit, frozenset({'self', 'A', 'B'}))
self.assertEqual(merged_metadata.deprecated_params,
frozenset({'test1', 'test2'}))
def get_metadata(cls):
"""
Retrieves metadata for the apply function. The description may be used
to advertise this action to the user. The parameters and their help
texts are additional information that are needed from the user. You can
create a section out of the inputs from the user and use
apply_from_section to apply
:return A FunctionMetadata object.
"""
data = FunctionMetadata.from_function(
cls.apply,
omit={'self', 'result', 'original_file_dict', 'file_diff_dict'})
data.name = cls.__name__
return data
def test_merge(self):
metadata1 = FunctionMetadata(
'main',
'Desc of main.\n',
'Returns 0 on success',
{'argc': ('argc desc', None), 'argv': ('argv desc', None)},
{'opt': ('opt desc', int, 88)},
{'self', 'A'},
{'test1'})
metadata2 = FunctionMetadata(
'process',
'Desc of process.\n',
'Returns the processed stuff.',
{'argc': ('argc desc from process', int),
'to_process': ('to_process desc', int)},
{'opt2': ('opt2 desc', str, 'hello')},
{'self', 'B'},
{'test2'})
metadata3 = FunctionMetadata('nodesc', '', '', {}, {})
merged_metadata = FunctionMetadata.merge(metadata1,
metadata2,
metadata3)
self.assertEqual(
merged_metadata.name,
"<Merged signature of 'main', 'process', 'nodesc'>")
self.assertEqual(merged_metadata.desc, 'Desc of process.\n')
self.assertEqual(merged_metadata.retval_desc,
'Returns the processed stuff.')
self.assertEqual(
merged_metadata.non_optional_params,
{'argc': ('argc desc from process', int),
'argv': ('argv desc', None),
'to_process': ('to_process desc', int)})
self.assertEqual(
merged_metadata.optional_params,
{'opt': ('opt desc', int, 88),
'opt2': ('opt2 desc', str, 'hello')})
self.assertEqual(
merged_metadata.omit,
frozenset({'self', 'A', 'B'}))
self.assertEqual(
merged_metadata.deprecated_params,
frozenset({'test1', 'test2'}))
def default(self, obj):
if hasattr(obj, "__json__"):
fdata = FunctionMetadata.from_function(obj.__json__)
params = self._filter_params(
fdata.optional_params, fdata.non_optional_params)
return obj.__json__(**params)
elif isinstance(obj, collections.Iterable):
return list(obj)
elif isinstance(obj, datetime):
return obj.isoformat()
elif hasattr(obj, "__getitem__") and hasattr(obj, "keys"):
return dict(obj)
elif hasattr(obj, "__dict__"):
return {member: getattr(obj, member)
for member in get_public_members(obj)}
return json.JSONEncoder.default(self, obj)
def get_metadata(self):
"""
Retrieves metadata for the apply function. The description may be used
to advertise this action to the user. The parameters and their help
texts are additional information that are needed from the user. You can
create a section out of the inputs from the user and use
apply_from_section to apply
:return: A FunctionMetadata object.
"""
data = FunctionMetadata.from_function(
self.apply,
omit={'self', 'result', 'original_file_dict', 'file_diff_dict'})
if hasattr(self, 'description'):
data.desc = self.description
data.name = self.__class__.__name__
data.id = id(self)
return data
def default(self, obj):
if hasattr(obj, "__json__"):
fdata = FunctionMetadata.from_function(obj.__json__)
params = self._filter_params(fdata.optional_params,
fdata.non_optional_params)
return obj.__json__(**params)
elif isinstance(obj, collections.Iterable):
return list(obj)
elif isinstance(obj, datetime):
return obj.isoformat()
elif hasattr(obj, "__getitem__") and hasattr(obj, "keys"):
return dict(obj)
elif hasattr(obj, "__dict__"):
return {
member: getattr(obj, member)
for member in get_public_members(obj)
}
return json.JSONEncoder.default(self, obj)
def test_add_deprecated_param(self):
uut = FunctionMetadata(
"test",
non_optional_params={'not_optional': ('desc', str)},
optional_params={'optional': ('desc2', str, 'default')})
uut.add_deprecated_param('optional', 'old_optional')
uut.add_deprecated_param('not_optional', 'old_not_optional')
self.assertEqual(uut.non_optional_params,
{'not_optional': ('desc', str)})
self.assertEqual(uut.optional_params,
{'optional': ('desc2', str, 'default'),
'old_optional': ('desc2', str, 'default'),
'old_not_optional': ('desc', str, None)})
def _deprecate_decorator(func):
def wrapping_function(*args, **kwargs):
for arg, depr_arg_and_modifier in depr_args.items():
deprecated_arg, _func = (
depr_arg_and_modifier
if isinstance(depr_arg_and_modifier, tuple)
else (depr_arg_and_modifier, lambda x: x))
if deprecated_arg in kwargs and arg not in kwargs:
print("The setting `{}` is deprecated. Please use `{}` "
"instead.".format(deprecated_arg, arg))
kwargs[arg] = _func.__call__(kwargs[deprecated_arg])
del kwargs[deprecated_arg]
return func(*args, **kwargs)
new_metadata = FunctionMetadata.from_function(func)
for arg, depr_arg_and_modifier in depr_args.items():
deprecated_arg = (depr_arg_and_modifier[0]
if isinstance(depr_arg_and_modifier, tuple)
else depr_arg_and_modifier)
new_metadata.add_alias(arg, deprecated_arg)
wrapping_function.__metadata__ = new_metadata
return wrapping_function
def _func_decorator(func):
@wraps(func)
def _new_func(self, *args, **kwargs):
if self.section.aspects:
aspects = self.section.aspects
for arg, aspect_value in aspectable_setting.items():
# Explicit setting takes priority
if arg in self.section:
continue
if isinstance(aspect_value, aspectclass):
kwargs[arg] = aspects.get(aspect_value) is not None
if isinstance(aspect_value, Taste):
aspect_instance = aspects.get(aspect_value.aspect_name)
if aspect_instance:
kwargs[arg] = aspect_instance.tastes[
aspect_value.name]
return func(self, *args, **kwargs)
# Keep metadata
_new_func.__metadata__ = FunctionMetadata.from_function(func)
return _new_func
def get_body_checks_metadata(cls):
return FunctionMetadata.from_function(
cls.check_body,
omit={"self", "body"})
def get_metadata(cls):
return FunctionMetadata.from_function(cls.run, omit={"self", "filename", "file", "dependency_results"})
def run(self, filename=None, file=None, **kwargs):
"""
Runs the wrapped tool.
:param filename:
The filename of the file being linted. ``None`` for project
scope.
:param file:
The content of the file being linted. ``None`` for project
scope.
"""
# Get the **kwargs params to forward to `generate_config()`
# (from `_create_config()`).
generate_config_kwargs = FunctionMetadata.filter_parameters(
self._get_generate_config_metadata(), kwargs)
with self._create_config(
filename,
file,
**generate_config_kwargs) as config_file:
# And now retrieve the **kwargs for `create_arguments()`.
create_arguments_kwargs = (
FunctionMetadata.filter_parameters(
self._get_create_arguments_metadata(), kwargs))
# The interface of create_arguments is different for local
# and global bears, therefore we must check here, what kind
# of bear we have.
if isinstance(self, LocalBear):
args = self.create_arguments(filename,
file, config_file,
**create_arguments_kwargs)
else:
args = self.create_arguments(config_file,
**create_arguments_kwargs)
try:
args = tuple(args)
except TypeError:
self.err('The given arguments '
'{!r} are not iterable.'.format(args))
return
arguments = (self.get_executable(),) + args
self.debug("Running '{}'".format(' '.join(arguments)))
output = run_shell_command(
arguments,
stdin=''.join(file) if options['use_stdin'] else None,
cwd=self.get_config_dir())
output = tuple(compress(
output,
(options['use_stdout'], options['use_stderr'])))
if len(output) == 1:
output = output[0]
process_output_kwargs = FunctionMetadata.filter_parameters(
self._get_process_output_metadata(), kwargs)
return self.process_output(output, filename, file,
**process_output_kwargs)
def _get_generate_config_metadata(cls):
return FunctionMetadata.from_function(cls.generate_config,
omit={"filename", "file"})
def _get_generate_config_metadata(cls):
return FunctionMetadata.from_function(
cls.generate_config,
omit={"filename", "file"})
def _get_create_arguments_metadata(cls):
return FunctionMetadata.from_function(
cls.create_arguments,
omit={"self", "filename", "file", "config_file"})
def get_body_checks_metadata(cls):
return FunctionMetadata.from_function(
cls.check_body,
omit={"self", "body"})
def test_construction(self):
self.check_function_metadata_data_set(FunctionMetadata('name'), 'name')
def get_shortlog_checks_metadata(cls):
return FunctionMetadata.from_function(
cls.check_shortlog,
omit={"self", "shortlog"})
def get_issue_checks_metadata(cls):
return FunctionMetadata.from_function(
cls.check_issue_reference,
omit={'self', 'body'})
def get_metadata(cls):
return FunctionMetadata.from_function(cls.__init__, omit={"self"})
def get_shortlog_checks_metadata(cls):
return FunctionMetadata.from_function(
cls.check_shortlog,
omit={"self", "shortlog"})
