def execute_python_code_in_parallel_thread(file):
""" This runs in a separate thread. """
var_numbers = VarMiddle().value(file)
nested_for_blocks = NestedBlocks(2, block_type=BlockType.FOR).value(file)
nested_if_blocks = NestedBlocks(2, block_type=BlockType.IF).value(file)
entropy = Entropy().value(file)
spaces = SpacesCounter().value(file)
concat_str_number = StringConcatFinder().value(file)
return file, var_numbers, nested_for_blocks, nested_if_blocks, entropy, spaces, concat_str_number
def main():
exit_status = -1
try:
depth_for = 2
depth_if = 2
parser = argparse.ArgumentParser(
description=
'Find the pattern which has the largest impact on readability')
parser.add_argument('--filename', help='path for Java file')
parser.add_argument(
'--version',
action='version',
version='%(prog)s {version}'.format(version=__version__))
args = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
if args:
java_file = str(Path(os.getcwd(), args.filename))
order_queue = queue.Queue()
order_queue.put([
VarMiddle().value(java_file),
'variable declaration in the middle of the function'
])
order_queue.put([
NestedBlocks(depth_for,
block_type=BlockType.FOR).value(java_file),
'nested for cycle with depth = {}'.format(depth_for)
])
order_queue.put([
NestedBlocks(depth_if,
block_type=BlockType.IF).value(java_file),
'nested if condition with depth = 2'.format(depth_if)
])
order_queue.put([
StringConcatFinder().value(java_file),
'string concatenation with operator +'
])
lines, output_string = order_queue.get()
if not lines:
print('Your code is perfect in aibolit\'s opinion')
for line in lines:
if line:
print('Line {}. Low readability due to: {}'.format(
line, output_string))
order_queue.task_done()
exit_status = 0
except KeyboardInterrupt:
exit_status = -1
sys.exit(exit_status)
def test_variable_after_curly_braces(self):
filepath = self.current_directory / "15.java"
ast = AST.build_from_javalang(build_ast(filepath))
pattern = VarMiddle()
lines = pattern.value(ast)
self.assertEqual(lines, [])
def test_variable_inside_lambda(self):
pattern = VarMiddle()
lines = pattern.value(
os.path.dirname(os.path.realpath(__file__)) + '/16.java')
self.assertEqual(lines, [])
def main():
exit_status = -1
patterns_list = [
'var_middle_number', 'this_find_number', 'string_concat_number',
'instance_of_number', 'method_chain_number', 'var_decl_diff_number_11',
'var_decl_diff_number_7', 'var_decl_diff_number_5',
'super_method_call_number', 'force_type_cast_number', 'asserts_number',
'setter_number', 'empty_rethrow_number',
'prohibited_class_names_number', 'return_in_if_number',
'impl_multi_number', 'many_prim_ctors_number', 'multiple_try_number',
'non_final_field_number', 'null_check_number', 'part_sync_number',
'red_catch_number', 'return_null_number'
]
try:
parser = argparse.ArgumentParser(
description=
'Find the pattern which has the largest impact on readability')
parser.add_argument('--filename', help='path for Java file')
parser.add_argument(
'--version',
action='version',
version='%(prog)s {version}'.format(version=__version__))
args = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
if args:
java_file = str(Path(os.getcwd(), args.filename))
halstead_volume = find_halstead(java_file)
var_numbers = VarMiddle().value(java_file)
entropy = Entropy().value(java_file)
left_space_variance, right_space_variance, max_left_space_diff, max_right_space_diff \
= IndentationCounter().value(java_file)
concat_str_number = StringConcatFinder().value(java_file)
instance_of_lines = InstanceOf().value(java_file)
method_chain_lines = MethodChainFind().value(java_file)
var_decl_diff_lines_5 = VarDeclarationDistance(
lines_th=5).value(java_file)
var_decl_diff_lines_7 = VarDeclarationDistance(
lines_th=7).value(java_file)
var_decl_diff_lines_11 = VarDeclarationDistance(
lines_th=11).value(java_file)
super_m_lines = SuperMethod().value(java_file)
force_type_cast_number = ForceTypeCastingFinder().value(java_file)
this_lines = ThisFinder().value(java_file)
asserts_lines = AssertInCode().value(java_file)
setter_lines = ClassicSetter().value(java_file)
empty_rethrow_lines = EmptyRethrow().value(java_file)
prohibited_class_names = ErClass().value(java_file)
if_return_lines = CountIfReturn().value(java_file)
impl_multi_lines = ImplementsMultiFinder().value(java_file)
many_prim_ctors_lines = ManyPrimaryCtors().value(java_file)
multiple_try_lines = MultipleTry().value(java_file)
non_final_field_lines = NonFinalAttribute().value(java_file)
null_check_lines = NullCheck().value(java_file)
part_sync_lines = PartialSync().value(java_file)
red_catch_lines = RedundantCatch().value(java_file)
return_null_lines = ReturnNull().value(java_file)
ncss_lightweight = NCSSMetric().value(java_file)
code_lines_dict = {
'var_middle_number': var_numbers,
'string_concat_number': concat_str_number,
'instance_of_number': instance_of_lines,
'method_chain_number': method_chain_lines,
'var_decl_diff_number_5': var_decl_diff_lines_5,
'var_decl_diff_number_7': var_decl_diff_lines_7,
'var_decl_diff_number_11': var_decl_diff_lines_11,
'super_method_call_number': super_m_lines,
'force_type_cast_number': force_type_cast_number,
'this_find_number': this_lines,
'asserts_number': asserts_lines,
'setter_number': setter_lines,
'empty_rethrow_number': empty_rethrow_lines,
'prohibited_class_names_number': prohibited_class_names,
'return_in_if_number': if_return_lines,
'impl_multi_number': impl_multi_lines,
'many_prim_ctors_number': many_prim_ctors_lines,
'multiple_try_number': multiple_try_lines,
'non_final_field_number': non_final_field_lines,
'null_check_number': null_check_lines,
'part_sync_number': part_sync_lines,
'red_catch_number': red_catch_lines,
'return_null_number': return_null_lines,
}
input_params = {
'var_middle_number': len(var_numbers),
'string_concat_number': len(concat_str_number),
'instance_of_number': len(instance_of_lines),
'method_chain_number': len(method_chain_lines),
'var_decl_diff_number_5': len(var_decl_diff_lines_5),
'var_decl_diff_number_7': len(var_decl_diff_lines_7),
'var_decl_diff_number_11': len(var_decl_diff_lines_11),
'super_method_call_number': len(super_m_lines),
'force_type_cast_number': len(force_type_cast_number),
'this_find_number': len(this_lines),
'asserts_number': len(asserts_lines),
'setter_number': len(setter_lines),
'empty_rethrow_number': len(empty_rethrow_lines),
'prohibited_class_names_number': len(prohibited_class_names),
'return_in_if_number': len(if_return_lines),
'impl_multi_number': len(impl_multi_lines),
'many_prim_ctors_number': len(many_prim_ctors_lines),
'multiple_try_number': len(multiple_try_lines),
'non_final_field_number': len(non_final_field_lines),
'null_check_number': len(null_check_lines),
'part_sync_number': len(part_sync_lines),
'red_catch_number': len(red_catch_lines),
'return_null_number': len(return_null_lines),
'entropy': entropy,
'halstead volume': halstead_volume,
'left_spaces_var': left_space_variance,
'right_spaces_var': right_space_variance,
'max_left_diff_spaces': max_left_space_diff,
'max_right_diff_spaces': max_right_space_diff,
'ncss_lightweight': ncss_lightweight,
}
sorted_result = predict(input_params)
found_pattern = False
code_lines = None
value = None
for iter, (key, val) in enumerate(sorted_result.items()):
if key in patterns_list:
if not found_pattern:
pattern = key
code_lines = code_lines_dict.get(key)
# We show only positive gradient, we won't add patterns
if code_lines and val > 1.00000e-20:
found_pattern = True
value = val
if not code_lines:
print('Your code is perfect in aibolit\'s opinion')
else:
output_str = \
'The largest contribution for {file} is {val} for \"{pattern}\" pattern'.format(
file=java_file,
pattern=pattern,
val=value)
print(output_str)
for line in code_lines:
if line:
print('Line {}. Low readability due to: {}'.format(
line, pattern))
exit_status = 0
except KeyboardInterrupt:
exit_status = -1
sys.exit(exit_status)
def test_for_scope_bad(self):
filepath = self.current_directory / "9.java"
ast = AST.build_from_javalang(build_ast(filepath))
pattern = VarMiddle()
lines = pattern.value(ast)
self.assertEqual(lines, [11])
def test_case_nested_class(self):
filepath = self.current_directory / "6.java"
ast = AST.build_from_javalang(build_ast(filepath))
pattern = VarMiddle()
lines = pattern.value(ast)
self.assertEqual(lines, [30, 33])
def test_case_with_multiline_method_declaration(self):
filepath = self.current_directory / "3.java"
ast = AST.build_from_javalang(build_ast(filepath))
pattern = VarMiddle()
lines = pattern.value(ast)
self.assertEqual(lines, [])
def test_case_with_empty_lines(self):
pattern = VarMiddle()
lines = pattern.value(os.path.dirname(os.path.realpath(__file__)) + '/4.java')
self.assertEqual(lines, [])
def test_case_with_multiline_method_declaration(self):
pattern = VarMiddle()
lines = pattern.value(os.path.dirname(os.path.realpath(__file__)) + '/3.java')
self.assertEqual(lines, [])
def test_bad_class(self):
pattern = VarMiddle()
lines = pattern.value(os.path.dirname(os.path.realpath(__file__)) + '/2.java')
self.assertEqual(lines, [9, 16])
def test_good_class(self):
pattern = VarMiddle()
lines = pattern.value(
os.path.dirname(os.path.realpath(__file__)) + '/1.java')
assert lines == []
def test_declaration_after_super_class_method_call(self):
pattern = VarMiddle()
lines = pattern.value(
os.path.dirname(os.path.realpath(__file__)) + '/7.java')
self.assertEqual(lines, [14])
def test_annotation_with_parameters(self):
pattern = VarMiddle()
lines = pattern.value(
os.path.dirname(os.path.realpath(__file__)) + '/17.java')
self.assertEqual(lines, [22])
def test_variable_inside_lambda(self):
filepath = self.current_directory / "16.java"
ast = AST.build_from_javalang(build_ast(filepath))
pattern = VarMiddle()
lines = pattern.value(ast)
self.assertEqual(lines, [])
def test_annotation_with_parameters(self):
filepath = self.current_directory / "17.java"
ast = AST.build_from_javalang(build_ast(filepath))
pattern = VarMiddle()
lines = pattern.value(ast)
self.assertEqual(lines, [22])
def test_case_autoclosable(self):
pattern = VarMiddle()
lines = pattern.value(os.path.dirname(os.path.realpath(__file__)) + '/5.java')
self.assertEqual(lines, [])
def test_case_autoclosable(self):
filepath = self.current_directory / "5.java"
ast = AST.build_from_javalang(build_ast(filepath))
pattern = VarMiddle()
lines = pattern.value(ast)
self.assertEqual(lines, [])
def test_case_nested_class(self):
pattern = VarMiddle()
lines = pattern.value(os.path.dirname(os.path.realpath(__file__)) + '/6.java')
self.assertEqual(lines, [10, 22, 30, 33])
def test_declaration_after_super_class_method_call(self):
filepath = self.current_directory / "7.java"
ast = AST.build_from_javalang(build_ast(filepath))
pattern = VarMiddle()
lines = pattern.value(ast)
self.assertEqual(lines, [14])
def test_for_scope_bad(self):
pattern = VarMiddle()
lines = pattern.value(os.path.dirname(os.path.realpath(__file__)) + '/9.java')
self.assertEqual(lines, [11])
def test_variable_declared_after_for(self):
filepath = self.current_directory / "10.java"
ast = AST.build_from_javalang(build_ast(filepath))
pattern = VarMiddle()
lines = pattern.value(ast)
self.assertEqual(lines, [11])
def test_variable_declared_after_for(self):
pattern = VarMiddle()
lines = pattern.value(os.path.dirname(os.path.realpath(__file__)) + '/10.java')
self.assertEqual(lines, [11])
def test_catch_good(self):
pattern = VarMiddle()
lines = pattern.value(os.path.dirname(os.path.realpath(__file__)) + '/12.java')
self.assertEqual(lines, [])
def test_else_bad(self):
pattern = VarMiddle()
lines = pattern.value(os.path.dirname(os.path.realpath(__file__)) + '/14.java')
self.assertEqual(lines, [88])
def format_f(e):
return f'{e}-{e}'
FILEPATH_TO_READ = '/01/found-java-files.txt'
DIR_TO_CREATE = '03'
FILE_TO_SAVE = 'patterns.csv'
current_location: str = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__))
)
pattern_for = NestedBlocks(2, BlockType.FOR)
pattern_if = NestedBlocks(2, BlockType.IF)
pattern_var_middle = VarMiddle()
data = []
with open(current_location + FILEPATH_TO_READ) as fp:
for line in fp.readlines():
filename = line.strip()
var_middle = list(map(format_f, pattern_var_middle.value(filename)))
nested_fors = list(map(format_f, pattern_for.value(filename)))
nested_ifs = list(map(format_f, pattern_if.value(filename)))
data += [(
filename,
';'.join(nested_fors),
';'.join(nested_ifs),
';'.join(var_middle)
)]
if not os.path.isdir(DIR_TO_CREATE):
def test_variable_after_curly_braces(self):
pattern = VarMiddle()
lines = pattern.value(
os.path.dirname(os.path.realpath(__file__)) + '/15.java')
self.assertEqual(lines, [])
