similarity_explorer.cpp

Go to the documentation of this file.

/*
This file expect the output of parser.cpp
This code filter the output only printing the files similar to files that contains a given pattern passed as argc
The code filter every file that has the pattern as a substring, so be carefull with duplications
*/
 
#include <algorithm>
#include <utility>
 
#include "similarity_explorer.hpp"
#include <arkanjo/base/function/function_loader.hpp>
#include <arkanjo/base/function/function_printer.hpp>
#include <arkanjo/formatter/format_manager.hpp>
 
using fm = FormatterManager;
 
int SimilarityExplorer::find_number_pairs_show(int number_pair_found) const {
    if (limit_on_results == UNLIMITED_RESULTS) {
        return number_pair_found;
    }
    return std::min(limit_on_results, number_pair_found);
}
 
bool SimilarityExplorer::match_pattern(const Function& function1, const Function& function2) const {
    bool match1 = function1.contains_given_pattern(pattern_to_match);
    bool match2 = function2.contains_given_pattern(pattern_to_match);
 
    if (both_path_need_to_match_pattern) {
        return match1 && match2;
    }
    return match1 || match2;
}
 
SimilarityExplorerEntry SimilarityExplorer::process_similar_path_pair(const Path& path1, const Path& path2) {
    FunctionLoader loader;
    auto function1 = loader.load_metadata(path1);
    auto location1 = function1.scope_location();
 
    auto function2 = loader.load_metadata(path2);
    auto location2 = function2.scope_location();
 
    if (!match_pattern(function1, function2))
        return {};
    if (limit_on_results != UNLIMITED_RESULTS && processed_results >= limit_on_results) {
        return {};
    }
    processed_results++;
 
    return {
        .path_a = FunctionPrinter::format_path_message_in_pair(function1),
        .path_b = FunctionPrinter::format_path_message_in_pair(function2),
        .dir_a = path1.relative_path().parent_path().string(),
        .dir_b = path2.relative_path().parent_path().string(),
        .filename_a = path1.relative_path().filename().string(),
        .filename_b = path2.relative_path().filename().string(),
        .func_a = function1.name(),
        .func_b = function2.name(),
        .start_a = location1.declaration,
        .start_b = location2.declaration,
        .end_a = location1.end,
        .end_b = location2.end,
        .duplicated_lines = location1.size(),
        .similarity = similarity_table->get_similarity(path1, path2),
    };
}
 
int SimilarityExplorer::find_number_pair_found(const std::vector<SimilarPair>& similar_path_pairs) const {
    int count = 0;
    FunctionLoader loader;
    for (const auto& similar_pair : similar_path_pairs) {
        const Path& path1 = similarity_table->get_path(similar_pair.id1);
        const Path& path2 = similarity_table->get_path(similar_pair.id2);
 
        auto function1 = loader.load_metadata(path1);
        auto function2 = loader.load_metadata(path2);
 
        if (match_pattern(function1, function2))
            count++;
    }
    return count;
}
 
std::vector<SimilarPair> SimilarityExplorer::build_similar_path_pairs() {
    std::vector<SimilarPair> similar_path_pairs = similarity_table->get_all_similar_pairs();
    if (sorted_by_number_of_duplicated_code) {
        similarity_table->sort_pairs_by_line_number(similar_path_pairs);
    } else {
        similarity_table->sort_pairs_by_similarity(similar_path_pairs);
    }
    return similar_path_pairs;
}
 
void SimilarityExplorer::explorer_clusters() {
    auto clusters_info = similarity_table->get_clusters_info(sorted_by_number_of_duplicated_code);
 
    int clusters_to_show = limit_on_results > 0 
        ? std::min(limit_on_results, (int)clusters_info.size()) 
        : (int)clusters_info.size();
 
    for (int idx = 0; idx < clusters_to_show; idx++) {
        const auto& info = clusters_info[idx];
        fm::write("Cluster #" + std::to_string(idx + 1)
          + " (Files: " + std::to_string(info.paths.size())
          + ", Pairs: " + std::to_string(info.total_pairs)
          + ", Lines: " + std::to_string(info.total_lines)
          + ", Score: " + std::to_string(info.score()) + ")");
        fm::write(Utils::LIMITER_PRINT);
 
        std::vector<SimilarityExplorerEntry> entries{};
        FunctionLoader loader;
        for (const auto& path : info.paths) {
            auto function = loader.load_metadata(path);
            auto location = function.scope_location();
            entries.push_back({
                FunctionPrinter::format_path_message_in_pair(function),
                "",
                path.relative_path().parent_path().string(),
                "",
                path.relative_path().filename().string(),
                "",
                function.name(),
                "",
                location.declaration,
                0,
                location.end,
                0,
                location.size(),
                0.0,
            });
        }
 
        fm::write(TEMPLATE_PROCESSED_RESULTS_CLUSTERS, entries, Format::AUTO, [](size_t i) {
            return (i % 2 == 0)
                ? fm::get_formatter()->style().at("row_even")
                : fm::get_formatter()->style().at("row_odd");
        });
        fm::write("");
    }
}
 
void SimilarityExplorer::explorer() {
    auto start = std::chrono::high_resolution_clock::now();
 
    if (mode_verbose)
        fm::write("Building pairs of similar paths...");
 
    auto similar_path_pairs = build_similar_path_pairs();
 
    if (mode_verbose)
        fm::write("Finding pair of numbers found and show...");
 
    int number_pair_found = find_number_pair_found(similar_path_pairs);
    int number_pairs_show = find_number_pairs_show(number_pair_found);
 
    if (mode_verbose)
        fm::time("Execution time build similar path pairs:", start);
 
    fm::write(TEMPLATE_INITIAL_TEXT, SimilarityExplorerInitialMessage{
        number_pair_found, number_pairs_show
    }, Format::TEXT);
    fm::write(Utils::LIMITER_PRINT);
 
    std::vector<SimilarityExplorerEntry> vector_entry = {};
    for (const auto& similar_pair : similar_path_pairs) {
        const Path& path1 = similarity_table->get_path(similar_pair.id1);
        const Path& path2 = similarity_table->get_path(similar_pair.id2);
 
        auto entry = process_similar_path_pair(path1, path2);
        if (entry.duplicated_lines <= 0)
            continue;
        vector_entry.push_back(entry);
    }
    fm::write(template_processed_results_output, vector_entry, Format::AUTO, [](size_t i) {
        return (i % 2 == 0)
            ? fm::get_formatter()->style().at("row_even")
            : fm::get_formatter()->style().at("row_odd");
    });
}
 
SimilarityExplorer::SimilarityExplorer(Similarity_Table* table)
    : similarity_table(table),
      limit_on_results(0),
      pattern_to_match(""),
      both_path_need_to_match_pattern(false),
      sorted_by_number_of_duplicated_code(false),
      use_clusters(false) {}
 
bool SimilarityExplorer::validate(const ParsedOptions& options) {
    try {
        if (auto limiter = options.get_as<int>("limiter"))
            this->limit_on_results = *limiter;
    } catch (const std::invalid_argument&) {
        throw CLIError(
            "--limiter must be a valid number (passing " +
            std::string(*options.get("limiter")) + ")"
        );
    } catch (const std::out_of_range&) {
        throw CLIError("--limiter outside the permitted range");
    }
 
    return true;
}
 
void SimilarityExplorer::print_template_variables() {
    SimilarityExplorerEntry entry = {};
    json j;
    to_json(j, entry);
 
    fm::write(BOLD("Available variables for --template:"));
    for (const auto& [k, _] : j.items()) {
        fm::write("  {" + k + "}");
    }
 
    fm::write("");
    fm::write(BOLD("Example:"));
    fm::write("  arkanjo explorer --template \"{func_a:function} ~ {func_b:function} ({duplicated_lines:number} lines)\"\n");
}
 
bool SimilarityExplorer::run(const ParsedOptions& options) {
    if (options.has("template-help")) {
        print_template_variables();
        return true;
    }
 
    if (auto pattern = options.get("pattern"))
        this->pattern_to_match = *pattern;
 
    both_path_need_to_match_pattern = options.has("both-match");
    sorted_by_number_of_duplicated_code = options.has("sort");
    use_clusters = options.has("cluster");
 
    if (auto template_value = options.get("template"))
        this->template_processed_results_output = *template_value;
 
    if (use_clusters) {
        explorer_clusters();
        return true;
    }
 
    explorer();
    return true;
}