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
 
bool IgnoreMatcher::is_skipped_dir_name(const std::string& name) {
    static const std::vector<std::string> kSkipDirs = {
        ".git", "node_modules", "__pycache__", ".venv"
    };
    bool skipped = false;
    for (const auto& skip : kSkipDirs) {
        if (name == skip) { skipped = true; }
    }
    return skipped;
}
 
// ── 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 normalize_base(const std::string& base) {
    std::string out = base;
    if (out.rfind("./", 0) == 0) { out.erase(0, 2); }
    if (out == ".") { out.clear(); }
    while (!out.empty() && out.back() == '/') { out.pop_back(); }
    return out;
}
 
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 = normalize_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(rule.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::push_rule(Rule&& rule) {
    std::string base = rule.base;
    rules_.push_back(std::move(rule));
    by_base_[base].push_back(rules_.size() - 1);
}
 
void IgnoreMatcher::add_pattern(const std::string& pattern,
                                const fs::path& base) {
    std::string trimmed = trim(pattern);
    if (trimmed.empty() || trimmed[0] == '#') { return; }
    push_rule(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; }
        push_rule(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();
    by_base_.clear();
    reset_regex_evals();
    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) {
    try {
        fs::recursive_directory_iterator it(
            canonical_root,
            fs::directory_options::skip_permission_denied);
        const fs::recursive_directory_iterator end;
        for (; it != end; ++it) {
            visit_discovery_entry(it, canonical_root, root_gi);
        }
    } catch (const std::exception& e) {
        logger->warn("Recursive gitignore scan aborted: {}", e.what());
    }
}
 
void IgnoreMatcher::visit_discovery_entry(
    fs::recursive_directory_iterator& it,
    const fs::path& canonical_root, const fs::path& root_gi) {
    const auto& entry = *it;
    if (entry.is_directory()) {
        if (prunes_discovery(entry.path(), canonical_root)) {
            it.disable_recursion_pending();
        }
        return;
    }
    if (entry.path().filename() != ".gitignore"
        || entry.path() == root_gi) {
        return;
    }
    auto rel_dir = fs::relative(entry.path().parent_path(),
                                canonical_root);
    load_file(entry.path(), to_slash(rel_dir));
}
 
bool IgnoreMatcher::prunes_discovery(
    const fs::path& dir, const fs::path& canonical_root) const {
    if (is_skipped_dir_name(dir.filename().string())) { return true; }
    auto rel = to_slash(fs::relative(dir, canonical_root));
    return !rel.empty() && is_ignored(rel, true);
}
 
// ── Bucketed matching (gh#161) ───────────────────────────
 
namespace {
 
using BaseIndex =
    std::unordered_map<std::string, std::vector<std::size_t>>;
 
constexpr std::size_t kNoRule = static_cast<std::size_t>(-1);
 
struct BucketCursor {
    const std::vector<std::size_t>* indices; 
    std::size_t remaining;                   
};
 
void collect_buckets(const BaseIndex& index, const std::string& rel_path,
                     std::vector<BucketCursor>& out) {
    auto take = [&](const std::string& base) {
        auto found = index.find(base);
        if (found != index.end() && !found->second.empty()) {
            out.push_back({&found->second, found->second.size()});
        }
    };
    take("");
    for (std::size_t i = 0; i < rel_path.size(); ++i) {
        if (rel_path[i] == '/') { take(rel_path.substr(0, i)); }
    }
}
 
std::size_t pop_highest(std::vector<BucketCursor>& cursors) {
    std::size_t best = kNoRule;
    BucketCursor* from = nullptr;
    for (auto& cursor : cursors) {
        if (cursor.remaining == 0) { continue; }
        std::size_t candidate = (*cursor.indices)[cursor.remaining - 1];
        if (from == nullptr || candidate > best) {
            best = candidate;
            from = &cursor;
        }
    }
    if (from != nullptr) { --from->remaining; }
    return best;
}
 
bool rule_matches(const IgnoreMatcher::Rule& rule,
                  const std::string& rel_path, bool is_dir,
                  std::atomic<std::uint64_t>& evals) {
    evals.fetch_add(1, std::memory_order_relaxed);
    bool matched = std::regex_match(rel_path, rule.re_under);
    // For dir_only rules an exact match only counts when the path is
    // itself a directory — a regular file named like a `dir/` pattern
    // is NOT excluded.
    if (!matched && (!rule.dir_only || is_dir)) {
        evals.fetch_add(1, std::memory_order_relaxed);
        matched = std::regex_match(rel_path, rule.re_exact);
    }
    return matched;
}
 
} // namespace
 
bool IgnoreMatcher::is_ignored(const std::string& rel_path,
                               bool is_dir) const {
    std::vector<BucketCursor> cursors;
    collect_buckets(by_base_, rel_path, cursors);
 
    bool ignored = false;
    for (std::size_t idx = pop_highest(cursors); idx != kNoRule;
         idx = pop_highest(cursors)) {
        if (rule_matches(rules_[idx], rel_path, is_dir, regex_evals_)) {
            ignored = !rules_[idx].negate;
            break;
        }
    }
    return ignored;
}
 
} // namespace entropic