ignore_matcher.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/mcp/servers/ignore_matcher.h>
#include <entropic/types/logging.h>
 
#include <fstream>
#include <sstream>
 
namespace fs = std::filesystem;
static auto logger = entropic::log::get("mcp.filesystem.ignore");
 
namespace entropic {
 
namespace {
 
std::string trim(const std::string& s) {
    auto begin = s.find_first_not_of(" \t\r\n");
    auto end = s.find_last_not_of(" \t\r\n");
    return (begin == std::string::npos)
        ? std::string{}
        : s.substr(begin, end - begin + 1);
}
 
std::string to_slash(const fs::path& p) {
    auto s = p.generic_string();
    return s;
}
 
bool is_regex_meta(char c) {
    switch (c) {
    case '.': case '+': case '(': case ')':
    case '|': case '^': case '$': case '{':
    case '}': case '\\':
        return true;
    default:
        return false;
    }
}
 
} // namespace
 
// ── Pattern compilation ──────────────────────────────────
 
namespace {
 
void emit_star(const std::string& pattern, size_t& i, std::string& out) {
    bool double_star = (i + 1 < pattern.size())
        && pattern[i + 1] == '*';
    if (!double_star) { out += "[^/]*"; return; }
    out += ".*";
    ++i;
    if (i + 1 < pattern.size() && pattern[i + 1] == '/') {
        ++i;
    }
}
 
void emit_bracket(const std::string& pattern, size_t& i,
                  std::string& out) {
    out += '[';
    ++i;
    while (i < pattern.size() && pattern[i] != ']') {
        out += pattern[i];
        ++i;
    }
    out += ']';
}
 
void emit_escape(const std::string& pattern, size_t& i,
                 std::string& out) {
    char next = pattern[i + 1];
    if (is_regex_meta(next)) { out += '\\'; }
    out += next;
    ++i;
}
 
} // namespace
 
namespace {
 
void emit_one(const std::string& pattern, size_t& i,
              std::string& out) {
    char c = pattern[i];
    bool handled = true;
    switch (c) {
    case '*': emit_star(pattern, i, out); break;
    case '?': out += "[^/]"; break;
    case '[': emit_bracket(pattern, i, out); break;
    case '\\':
        if (i + 1 < pattern.size()) {
            emit_escape(pattern, i, out);
        } else {
            handled = false;
        }
        break;
    default: handled = false; break;
    }
    if (!handled) {
        if (is_regex_meta(c)) { out += '\\'; }
        out += c;
    }
}
 
} // namespace
 
std::string IgnoreMatcher::pattern_to_regex(const std::string& pattern) {
    std::string out;
    out.reserve(pattern.size() * 2);
    for (size_t i = 0; i < pattern.size(); ++i) {
        emit_one(pattern, i, out);
    }
    return out;
}
 
namespace {
 
void strip_flags(std::string& body, IgnoreMatcher::Rule& rule) {
    if (!body.empty() && body[0] == '!') {
        rule.negate = true;
        body.erase(0, 1);
    }
    if (!body.empty() && body.back() == '/') {
        rule.dir_only = true;
        body.pop_back();
    }
}
 
std::string make_base_prefix(const std::string& base) {
    if (base.empty()) { return {}; }
    std::string raw = base + "/";
    std::string out;
    for (char c : raw) {
        if (is_regex_meta(c) || c == '*' || c == '?' || c == '[') {
            out += '\\';
        }
        out += c;
    }
    return out;
}
 
std::regex compile_or_never(const std::string& src,
                            const std::string& original_pattern) {
    try {
        return std::regex(src);
    } catch (const std::regex_error& e) {
        logger->warn("Skipping malformed ignore pattern '{}': {}",
                     original_pattern, e.what());
        return std::regex("(?!)");
    }
}
 
} // namespace
 
IgnoreMatcher::Rule IgnoreMatcher::compile_pattern(
    const std::string& pattern, const std::string& base) {
    Rule rule;
    rule.original = pattern;
    rule.base = base;
 
    std::string body = pattern;
    strip_flags(body, rule);
    bool root_anchored = !body.empty() && body[0] == '/';
    if (root_anchored) { body.erase(0, 1); }
    bool anchored = root_anchored
        || body.find('/') != std::string::npos;
 
    std::string regex_body = pattern_to_regex(body);
    std::string base_prefix = make_base_prefix(base);
    std::string anchor_left = anchored
        ? ("^" + base_prefix)
        : ("^" + base_prefix + "(?:.*/)?");
 
    rule.re_exact = compile_or_never(
        anchor_left + regex_body + "$", pattern);
    rule.re_under = compile_or_never(
        anchor_left + regex_body + "/.*$", pattern);
    return rule;
}
 
// ── Public API ───────────────────────────────────────────
 
void IgnoreMatcher::add_pattern(const std::string& pattern,
                                const fs::path& base) {
    std::string trimmed = trim(pattern);
    if (trimmed.empty() || trimmed[0] == '#') { return; }
    rules_.push_back(compile_pattern(trimmed, to_slash(base)));
}
 
void IgnoreMatcher::load_file(const fs::path& path,
                              const std::string& base) {
    std::ifstream in(path);
    if (!in.is_open()) { return; }
    std::string line;
    int loaded = 0;
    while (std::getline(in, line)) {
        std::string trimmed = trim(line);
        if (trimmed.empty() || trimmed[0] == '#') { continue; }
        rules_.push_back(compile_pattern(trimmed, base));
        ++loaded;
    }
    std::string base_label = base.empty() ? std::string("<root>") : base;
    logger->info("Loaded {} ignore rules from {} (base='{}')",
                 loaded, path.string(), base_label);
}
 
void IgnoreMatcher::load(const fs::path& root) {
    rules_.clear();
    if (!fs::exists(root) || !fs::is_directory(root)) {
        logger->warn("IgnoreMatcher::load: root does not exist: {}",
                     root.string());
        return;
    }
 
    auto canonical_root = fs::weakly_canonical(root);
    fs::path root_gi = canonical_root / ".gitignore";
    if (fs::exists(root_gi)) { load_file(root_gi, ""); }
 
    load_nested_gitignores(canonical_root, root_gi);
 
    fs::path explorer = canonical_root / ".explorerignore";
    if (fs::exists(explorer)) { load_file(explorer, ""); }
}
 
void IgnoreMatcher::load_nested_gitignores(
    const fs::path& canonical_root, const fs::path& root_gi) {
    // Recursively discover .gitignore files in subdirectories. We skip
    // the root one (already loaded) and directories the accumulated
    // rule set already excludes (avoids descending into node_modules
    // just to find an irrelevant .gitignore).
    try {
        auto it = fs::recursive_directory_iterator(
            canonical_root,
            fs::directory_options::skip_permission_denied);
        for (auto& entry : it) {
            if (!entry.is_regular_file()) { continue; }
            if (entry.path().filename() != ".gitignore") { continue; }
            if (entry.path() == root_gi) { continue; }
            auto rel_dir = fs::relative(entry.path().parent_path(),
                                        canonical_root);
            load_file(entry.path(), to_slash(rel_dir));
        }
    } catch (const std::exception& e) {
        logger->warn("Recursive gitignore scan aborted: {}", e.what());
    }
}
 
bool IgnoreMatcher::is_ignored(const std::string& rel_path,
                               bool is_dir) const {
    bool ignored = false;
    for (const auto& rule : rules_) {
        bool match_under = std::regex_match(rel_path, rule.re_under);
        bool match_exact = std::regex_match(rel_path, rule.re_exact);
        // For dir_only rules, an exact match only counts when the path
        // is itself a directory (a regular file with the same name as
        // a `dir/` pattern is NOT excluded). re_under always counts —
        // any descendant inherits the parent's exclusion.
        bool exact_counts = match_exact
            && (!rule.dir_only || is_dir);
        if (match_under || exact_counts) {
            ignored = !rule.negate;
        }
    }
    return ignored;
}
 
} // namespace entropic