similarity_explorer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <utility>
#include <vector>
 
#include <arkanjo/base/function/function.hpp>
#include <arkanjo/base/path.hpp>
#include <arkanjo/base/similarity_table.hpp>
 
#include <arkanjo/cli/cli_error.hpp>
#include <arkanjo/commands/command_base.hpp>
 
#include "similarity_explorer_entry.hpp"
 
class SimilarityExplorer : public CommandBase<SimilarityExplorer> {
  public:
    static constexpr int UNLIMITED_RESULTS = 0;      
    static constexpr const char* EMPTY_PATTERN = ""; 
 
    static constexpr CliOption options_[] = {
        {"limiter", 'l', RequiredArgument, "Limits the number of results shown to the user. By default, all results are shown."},
        {"pattern", 'p', RequiredArgument, "Defines a pattern that function names must match to be included in the results. A function is considered a match if the pattern is a substring of the function's concatenated file path and name (e.g., `path/to/file.c:function_name`)."},
        {"both-match", 'b', NoArgument, "Enable both-pattern matching. By default, the pattern only needs to match one function."},
        {"sort", 's', NoArgument, "Sort results by number of duplicated lines. By default, results are sorted by the similarity metric."},
        {"cluster", 'c', NoArgument, "Print results with cluster relationships from the similarity table."},
        {"verbose", 0, NoArgument, "Enable verbose output"},
        {"template", 't', RequiredArgument, "Output format template for each result entry. Run --template-help to see available variables and an example."},
        {"template-help", 0, NoArgument, "Show available template variables for --template."},
        OPTION_END
    };
    COMMAND_DESCRIPTION(
        "Explore duplicated functions detected in the project.")
 
    
    explicit SimilarityExplorer(Similarity_Table* _similarity_table);
 
    bool validate(const ParsedOptions& options) override;
 
    bool run(const ParsedOptions& options) override;
 
  private:
    static constexpr const char* TEMPLATE_PROCESSED_RESULTS = 
      "Functions find: {path_a} "
      "AND {path_b}"
      ", TOTAL NUMBER LINES IN FUNCTIONS: {duplicated_lines}";
    static constexpr const char* TEMPLATE_PROCESSED_RESULTS_CLUSTERS = 
      "Function find: {path_a}"
      ", TOTAL NUMBER LINES IN FUNCTION: {duplicated_lines}";
    static constexpr const char* TEMPLATE_INITIAL_TEXT =
      "It was found a total of {found:bold} "
      "pair of duplicate functions in the codebase. Which the first "
      "{show:bold} can be found below.";
      
    int INITIAL_PROCESSED_RESULTS = 0;                                                                                    ///< Initial counter for processed results
 
    Similarity_Table* similarity_table;                ///< Source of similarity data
    int limit_on_results;                              ///< Maximum number of results to show
    std::string pattern_to_match;                      ///< Pattern to filter results
    bool both_path_need_to_match_pattern;              ///< Whether both paths must match pattern
    bool sorted_by_number_of_duplicated_code;          ///< Whether to sort by line count
    bool use_clusters;                                 ///< Whether clusters be printed
    int processed_results = INITIAL_PROCESSED_RESULTS; ///< Counter for processed results
    bool mode_verbose = false;                         ///< Detailed execution information
    std::string template_processed_results_output = TEMPLATE_PROCESSED_RESULTS;
 
    int find_number_pairs_show(int number_pair_found) const;
 
    bool match_pattern(const Function& function1, const Function& function2) const;
 
    SimilarityExplorerEntry process_similar_path_pair(const Path& path1, const Path& path2);
 
    int find_number_pair_found(const std::vector<SimilarPair>& similar_path_pairs) const;
 
    std::vector<SimilarPair> build_similar_path_pairs();
 
    static void print_template_variables();
 
    void explorer_clusters();
 
    void explorer();
};