function_breaker_java.cpp

Go to the documentation of this file.

#include "function_breaker_java.hpp"
 
set<array<int, 3>> FunctionBreakerJava::find_start_end_and_depth_of_brackets(const vector<string>& brackets_content) {
    set<array<int, 3>> start_ends;
    int open_brackets = 0;
 
    vector<int> not_processed_open_brackets;
    auto process_open = [&](int line_number) {
        open_brackets++;
        not_processed_open_brackets.push_back(line_number);
    };
    auto process_close = [&](int line_number) {
        open_brackets--;
        if (open_brackets <= -1) {
            open_brackets = 0;
        } else {
            int matched_open_position = not_processed_open_brackets.back();
            not_processed_open_brackets.pop_back();
            int depth_of_open = not_processed_open_brackets.size();
            start_ends.insert({matched_open_position, line_number, depth_of_open});
        }
    };
 
    for (size_t i = 0; i < brackets_content.size(); i++) {
        auto line = brackets_content[i];
        for (auto c : line) {
            if (c == '{') {
                process_open(i);
            }
            if (c == '}') {
                process_close(i);
            }
        }
    }
    return start_ends;
}
 
set<pair<int, int>> FunctionBreakerJava::find_start_end_of_brackets_of_given_depth(vector<string> brackets_content, int depth) {
    set<pair<int, int>> ret;
    set<array<int, 3>> bracket_pairs = find_start_end_and_depth_of_brackets(brackets_content);
    for (auto [start, end, dep] : bracket_pairs) {
        if (dep == depth) {
            ret.insert({start, end});
        }
    }
    return ret;
}
 
int FunctionBreakerJava::find_position_first_open_bracket(const string& s) {
    for (size_t i = 0; i < s.size(); i++) {
        char c = s[i];
        if (c == '{') {
            return i;
        }
    }
    return -1;
}
 
string FunctionBreakerJava::extract_last_token_of_string(const string& s) {
    vector<string> tokens;
    string cur_token = "";
    for (size_t i = 0; i < s.size(); i++) {
        char c = s[i];
        if (Utils::is_empty_char(c) || Utils::is_special_char(c)) {
            if (!cur_token.empty()) {
                tokens.push_back(cur_token);
            }
            cur_token = "";
        } else {
            cur_token += c;
        }
    }
    if (!cur_token.empty()) {
        tokens.push_back(cur_token);
    }
 
    if (tokens.empty()) {
        return "";
    }
    return tokens.back();
}
 
Line_content FunctionBreakerJava::build_line_code(int line_number, const string& content) {
    Line_content ret;
    ret.line_number = line_number;
    ret.content = content;
    return ret;
}
 
vector<Line_content> FunctionBreakerJava::get_lines_before_body_function(const vector<string>& file_content, int line_start_body_function, int pos_bracket) {
    vector<Line_content> ret;
    Line_content line_bracket = build_line_code(line_start_body_function, file_content[line_start_body_function]);
    // remove everything after {
    while (int(line_bracket.content.size()) > pos_bracket) {
        line_bracket.content.pop_back();
    }
    ret.push_back(line_bracket);
 
    int until = max(0, line_start_body_function - NUMBER_OF_LINES_BEFORE_FOR_FUNCTION_NAME);
    for (int i = line_start_body_function - 1; i >= until; i--) {
        ret.push_back(build_line_code(i, file_content[i]));
    }
    reverse(ret.begin(), ret.end());
 
    // remove empty lines/empty characters at the end of lines
    while (!ret.empty()) {
        if (ret.back().content.empty()) {
            ret.pop_back();
            continue;
        }
        if (Utils::is_empty_char(ret.back().content.back())) {
            ret.back().content.pop_back();
            continue;
        }
        break;
    }
    return ret;
}
 
vector<Line_content> FunctionBreakerJava::remove_parenteses_at_the_end_of_the_scope(vector<Line_content> code) {
    if (code.empty() || code.back().content.back() != ')') {
        return code;
    }
    int count_close_parenteses = 0;
 
    while (!code.empty()) {
        string content = code.back().content;
        while (!content.empty()) {
            if (content.back() == ')') {
                count_close_parenteses++;
            }
            if (content.back() == '(') {
                count_close_parenteses--;
            }
            content.pop_back();
            if (count_close_parenteses == 0) {
                break;
            }
        }
        code.back().content = content;
        if (count_close_parenteses == 0) {
            break;
        }
        code.pop_back();
    }
    return code;
}
 
vector<Line_content> FunctionBreakerJava::remove_content_until_find_parenteses_at_the_end(vector<Line_content> code) {
    while (!code.empty()) {
        string content = code.back().content;
        while (!content.empty()) {
            if (content.back() == ')') {
                break;
            } else {
                content.pop_back();
            }
        }
        code.back().content = content;
        if (!content.empty()) {
            break;
        }
        code.pop_back();
    }
    return code;
}
 
vector<Line_content> FunctionBreakerJava::remove_parameters_of_declaration_c(vector<Line_content> code) {
    if (!ALLOW_STRUCTS) {
        auto ret = remove_content_until_find_parenteses_at_the_end(code);
        return remove_parenteses_at_the_end_of_the_scope(ret);
    }
    return remove_parenteses_at_the_end_of_the_scope(code);
}
 
vector<Line_content> FunctionBreakerJava::remove_parameters_of_declaration_java(vector<Line_content> code) {
    auto ret = remove_content_until_find_parenteses_at_the_end(code);
    return remove_parenteses_at_the_end_of_the_scope(ret);
}
 
vector<Line_content> FunctionBreakerJava::remove_parameters_of_declaration(vector<Line_content> code, PROGRAMMING_LANGUAGE programming_language) {
    if (programming_language == C) {
        return remove_parameters_of_declaration_c(code);
    }
    if (programming_language == JAVA) {
        return remove_parameters_of_declaration_java(code);
    }
    return code;
}
 
pair<string, int> FunctionBreakerJava::extract_function_name_and_line_from_declaration(const vector<string>& file_content, int line_start_body_function, PROGRAMMING_LANGUAGE programming_language) {
    int pos = find_position_first_open_bracket(file_content[line_start_body_function]);
    vector<Line_content> code_before_bracket = get_lines_before_body_function(file_content, line_start_body_function, pos);
    vector<Line_content> code = remove_parameters_of_declaration(code_before_bracket, programming_language);
    if (code.empty()) {
        return make_pair("", -1);
    }
    string ret = extract_last_token_of_string(code.back().content);
    return {ret, code.back().line_number};
}
 
vector<string> FunctionBreakerJava::build_function_content(int start_number_line, int end_number_line, const vector<string>& file_content) {
    string first_line = file_content[start_number_line];
    int to_remove = find_position_first_open_bracket(first_line);
 
    vector<string> function_content;
    reverse(first_line.begin(), first_line.end());
    for (int i = 0; i < to_remove; i++) {
        first_line.pop_back();
    }
    reverse(first_line.begin(), first_line.end());
    function_content.push_back(first_line);
    for (int i = start_number_line + 1; i <= end_number_line; i++) {
        function_content.push_back(file_content[i]);
    }
    return function_content;
}
 
vector<string> FunctionBreakerJava::build_header_content(int start_number_line, int line_declaration, const fs::path& relative_path, const string& function_name, const vector<string>& file_content) {
    vector<string> function_content;
    for (int i = line_declaration; i < start_number_line; i++) {
        function_content.push_back(file_content[i]);
    }
 
    string first_line = file_content[start_number_line];
    int to_keep = find_position_first_open_bracket(first_line);
    while (int(first_line.size()) > to_keep) {
        first_line.pop_back();
    }
    function_content.push_back(first_line);
    return function_content;
}
 
bool FunctionBreakerJava::is_body_function_empty(int start_number_line, int end_number_line, const vector<string>& file_content) {
    vector<string> function_content = build_function_content(start_number_line, end_number_line, file_content);
    int count_not_empty_char = 0;
    for (auto line : function_content) {
        for (auto c : line) {
            if (!Utils::is_empty_char(c)) {
                count_not_empty_char++;
            }
        }
    }
    bool is_empty = count_not_empty_char <= 2;
    return is_empty;
}
 
void FunctionBreakerJava::process_function(int start_number_line, int end_number_line, const fs::path& relative_path, const vector<string>& file_content, PROGRAMMING_LANGUAGE programming_language) {
    string first_line = file_content[start_number_line];
    auto [function_name, line_declaration] = extract_function_name_and_line_from_declaration(file_content, start_number_line, programming_language);
    if (function_name.empty()) {
        return;
    }
    if (IGNORE_EMPTY_FUNCTIONS) {
        if (is_body_function_empty(start_number_line, end_number_line, file_content)) {
            return;
        }
    }
 
    vector<string> function_content = build_function_content(start_number_line, end_number_line, file_content);
    vector<string> header_content = build_header_content(start_number_line, line_declaration, relative_path, function_name, file_content);
 
    create_source_file(start_number_line, end_number_line, relative_path, function_name, function_content);
    create_header_file(relative_path, function_name, header_content);
    create_info_file(line_declaration, start_number_line, end_number_line, relative_path, function_name);
}
 
fs::path FunctionBreakerJava::file_path_from_folder_path(const fs::path& file_path, const fs::path& folder_path) {
    return fs::relative(file_path, folder_path);
}
 
void FunctionBreakerJava::file_breaker_java(const fs::path& file_path, const fs::path& folder_path) {
    fs::path relative_path = file_path_from_folder_path(file_path, folder_path);
    vector<string> file_content = Utils::read_file_generic(file_path);
    set<pair<int, int>> start_end_of_functions = find_start_end_of_brackets_of_given_depth(file_content, JAVA_RELEVANT_DEPTH);
 
    for (auto [start_line, end_line] : start_end_of_functions) {
        process_function(start_line, end_line, relative_path, file_content, JAVA);
    }
}
 
FunctionBreakerJava::FunctionBreakerJava(const fs::path& file_path, const fs::path& folder_path) {
    file_breaker_java(file_path, folder_path);
}