ignore_matcher.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <atomic>
#include <cstdint>
#include <filesystem>
#include <regex>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace entropic {
 
class IgnoreMatcher {
public:
    IgnoreMatcher() = default;
 
    void load(const std::filesystem::path& root);
 
    void add_pattern(const std::string& pattern,
                     const std::filesystem::path& base = {});
 
    bool is_ignored(const std::string& rel_path,
                    bool is_dir) const;
 
    std::size_t rule_count() const { return rules_.size(); }
 
    std::uint64_t regex_evals() const {
        return regex_evals_.load(std::memory_order_relaxed);
    }
 
    void reset_regex_evals() const {
        regex_evals_.store(0, std::memory_order_relaxed);
    }
 
    static bool is_skipped_dir_name(const std::string& name);
 
    struct Rule {
        std::regex re_exact;      
        std::regex re_under;      
        bool negate = false;      
        bool dir_only = false;    
        std::string original;     
        std::string base;         
    };
 
private:
 
    static Rule compile_pattern(const std::string& pattern,
                                const std::string& base);
 
    static std::string pattern_to_regex(const std::string& pattern);
 
    void load_file(const std::filesystem::path& path,
                   const std::string& base);
 
    void load_nested_gitignores(const std::filesystem::path& canonical_root,
                                const std::filesystem::path& root_gi);
 
    void visit_discovery_entry(
        std::filesystem::recursive_directory_iterator& it,
        const std::filesystem::path& canonical_root,
        const std::filesystem::path& root_gi);
 
    bool prunes_discovery(
        const std::filesystem::path& dir,
        const std::filesystem::path& canonical_root) const;
 
    void push_rule(Rule&& rule);
 
    std::vector<Rule> rules_;     
 
    std::unordered_map<std::string, std::vector<std::size_t>> by_base_;
 
    mutable std::atomic<std::uint64_t> regex_evals_{0};
};
 
} // namespace entropic