Something went wrong. Try again.
semantic bufo search find-bufo.com
bufo
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271//! result filters — ported from the retired rust backend, with one deliberate narrowing.//!//! the rust api accepted arbitrary regex for `exclude`/`include`. logfire//! showed the only real-world pattern was `^bigbufo_`, which is now a//! server-side default. this port supports a documented subset instead of//! pulling in a regex engine://!//! - `^` at the start anchors to the beginning of the name//! - `$` at the end anchors to the end//! - `\b` at the start and/or end requires a word boundary (name chars are//! `[a-z0-9]`; `-`, `_`, `'` and the edges are boundaries) — the bufo bot's//! exclude list uses `\brip\b`//! - `|` separates alternatives (inside one comma-separated item)//! - everything else is a literal substring match//!//! any other regex metacharacter is matched literally and logged once per//! request so we can see whether anyone actually needs more.
const std = @import("std");const mem = std.mem;const Allocator = mem.Allocator;
const Edge = enum { none, anchor, word_boundary };
pub const Pattern = struct { start: Edge, end: Edge, literal: []const u8,
pub fn parse(raw: []const u8) Pattern { var s = mem.trim(u8, raw, " "); var start: Edge = .none; var end: Edge = .none; if (mem.startsWith(u8, s, "^")) { start = .anchor; s = s[1..]; } else if (mem.startsWith(u8, s, "\\b")) { start = .word_boundary; s = s[2..]; } if (mem.endsWith(u8, s, "$")) { end = .anchor; s = s[0 .. s.len - 1]; } else if (mem.endsWith(u8, s, "\\b")) { end = .word_boundary; s = s[0 .. s.len - 2]; } return .{ .start = start, .end = end, .literal = s }; }
fn isWordChar(c: u8) bool { return std.ascii.isAlphanumeric(c); }
fn edgeOk(edge: Edge, name: []const u8, at_start: bool, idx: usize) bool { return switch (edge) { .none => true, .anchor => if (at_start) idx == 0 else idx == name.len, .word_boundary => if (at_start) idx == 0 or !isWordChar(name[idx - 1]) else idx == name.len or !isWordChar(name[idx]), }; }
pub fn matches(self: Pattern, name: []const u8) bool { if (self.literal.len == 0) return false; var from: usize = 0; while (mem.indexOfPos(u8, name, from, self.literal)) |i| { const after = i + self.literal.len; if (edgeOk(self.start, name, true, i) and edgeOk(self.end, name, false, after)) return true; if (self.start == .anchor) return false; from = i + 1; } return false; }
/// diagnostic only: does this pattern use regex syntax the subset above /// doesn't implement? matching proceeds literally either way; the caller /// logs so we find out if a real client ever needs more. pub fn hasUnsupportedMeta(raw: []const u8) bool { if (mem.indexOfAny(u8, raw, ".*+?()[]{}") != null) return true; // the only escape we implement is \b; any other backslash is regex var rest = raw; while (mem.indexOfScalar(u8, rest, '\\')) |i| { if (i + 1 >= rest.len or rest[i + 1] != 'b') return true; rest = rest[i + 2 ..]; } return false; }};
/// parse a comma-separated list where each item may carry `|` alternatives/// into a flat pattern list (an item matches if any alternative matches).pub fn parsePatterns(alloc: Allocator, raw: ?[]const u8) ![]Pattern { var out: std.ArrayList(Pattern) = .empty; const text = raw orelse return out.items; var items = mem.splitScalar(u8, text, ','); while (items.next()) |item| { if (Pattern.hasUnsupportedMeta(item)) { std.log.warn("filter pattern uses unsupported regex syntax, matching literally: {s}", .{item}); } var alts = mem.splitScalar(u8, item, '|'); while (alts.next()) |alt| { const p = Pattern.parse(alt); if (p.literal.len > 0) try out.append(alloc, p); } } return out.items;}
fn anyMatch(patterns: []const Pattern, name: []const u8) bool { for (patterns) |p| if (p.matches(name)) return true; return false;}
/// the family-friendly blocklist, inherited from the rust backendconst inappropriate = [_][]const u8{ "bufo-juicy", "good-news-bufo-offers-suppository", "bufo-declines-your-suppository-offer", "tsa-bufo-gropes-you",};
/// the 4x4 big-bufo tile set, denied for every client unless `include`dconst tile_deny = Pattern{ .start = .anchor, .end = .none, .literal = "bigbufo_" };
pub const ContentFilter = struct { family_friendly: bool, exclude: []const Pattern, include: []const Pattern, formats: []const []const u8,
pub fn init( alloc: Allocator, family_friendly: bool, exclude: ?[]const u8, include: ?[]const u8, formats: ?[]const u8, ) !ContentFilter { return .{ .family_friendly = family_friendly, .exclude = try parsePatterns(alloc, exclude), .include = try parsePatterns(alloc, include), .formats = try parseFormats(alloc, formats), }; }
pub fn keeps(self: ContentFilter, name: []const u8, url: []const u8) bool { if (!matchesFormats(url, self.formats)) return false; if (self.family_friendly) { for (inappropriate) |blocked| { if (mem.indexOf(u8, name, blocked) != null) return false; } } if (anyMatch(self.include, name)) return true; if (tile_deny.matches(name)) return false; return !anyMatch(self.exclude, name); }};
fn parseFormats(alloc: Allocator, raw: ?[]const u8) ![]const []const u8 { var out: std.ArrayList([]const u8) = .empty; const text = raw orelse return out.items; var items = mem.splitScalar(u8, text, ','); while (items.next()) |item| { var f = mem.trim(u8, item, " "); f = mem.trimStart(u8, f, "."); if (f.len == 0) continue; const lowered = try alloc.alloc(u8, f.len); for (f, 0..) |c, i| lowered[i] = std.ascii.toLower(c); try out.append(alloc, lowered); } return out.items;}
fn matchesFormats(url: []const u8, allowed: []const []const u8) bool { if (allowed.len == 0) return true; const dot = mem.lastIndexOfScalar(u8, url, '.') orelse return false; const ext = url[dot + 1 ..]; for (allowed) |f| { if (std.ascii.eqlIgnoreCase(ext, f)) return true; } return false;}
// --- tests ---
const t = std.testing;
test "tiles denied by default, include restores" { var arena = std.heap.ArenaAllocator.init(t.allocator); defer arena.deinit(); const a = arena.allocator();
const default_filter = try ContentFilter.init(a, true, null, null, null); try t.expect(!default_filter.keeps("bigbufo_2_3", "https://x/bigbufo_2_3.png")); try t.expect(default_filter.keeps("bufo-happy", "https://x/bufo-happy.png"));
const opted_in = try ContentFilter.init(a, true, null, "bigbufo", null); try t.expect(opted_in.keeps("bigbufo_2_3", "https://x/bigbufo_2_3.png"));}
test "family-friendly blocklist" { var arena = std.heap.ArenaAllocator.init(t.allocator); defer arena.deinit(); const a = arena.allocator();
const strict = try ContentFilter.init(a, true, null, null, null); try t.expect(!strict.keeps("bufo-juicy", "https://x/bufo-juicy.png")); const lax = try ContentFilter.init(a, false, null, null, null); try t.expect(lax.keeps("bufo-juicy", "https://x/bufo-juicy.png"));}
test "include overrides exclude" { var arena = std.heap.ArenaAllocator.init(t.allocator); defer arena.deinit(); const a = arena.allocator();
const f = try ContentFilter.init(a, false, "party", "birthday-party", null); try t.expect(!f.keeps("bufo-party", "https://x/bufo-party.png")); try t.expect(f.keeps("bufo-birthday-party", "https://x/bufo-birthday-party.png"));}
test "pattern subset: anchors and alternation" { try t.expect(Pattern.parse("^bigbufo_").matches("bigbufo_0_0")); try t.expect(!Pattern.parse("^bigbufo_").matches("not-bigbufo_0_0")); try t.expect(Pattern.parse("party$").matches("bufo-party")); try t.expect(!Pattern.parse("party$").matches("bufo-party-hat")); try t.expect(Pattern.parse("^bufo-lgtm$").matches("bufo-lgtm")); try t.expect(!Pattern.parse("^bufo$").matches("bufo-lgtm"));}
test "word boundaries: the bot's \\brip\\b" { const rip = Pattern.parse("\\brip\\b"); try t.expect(rip.matches("bufo-rip")); try t.expect(rip.matches("rip-bufo")); try t.expect(rip.matches("bufo-rip-in-peace")); try t.expect(rip.matches("rip")); try t.expect(!rip.matches("bufo-trip")); try t.expect(!rip.matches("bufo-ripple")); try t.expect(!rip.matches("bufo-strips")); // a later occurrence can satisfy the boundary even if the first doesn't try t.expect(rip.matches("bufo-trips-then-rip")); try t.expect(!Pattern.hasUnsupportedMeta("\\brip\\b")); try t.expect(Pattern.hasUnsupportedMeta("\\d+"));
var arena = std.heap.ArenaAllocator.init(t.allocator); defer arena.deinit(); const ps = try parsePatterns(arena.allocator(), "excited|party, ^tsa"); try t.expectEqual(@as(usize, 3), ps.len); try t.expect(anyMatch(ps, "bufo-party")); try t.expect(anyMatch(ps, "tsa-bufo")); try t.expect(!anyMatch(ps, "bufo-tsa"));}
test "formats filter by extension, case-insensitive, empty allows all" { var arena = std.heap.ArenaAllocator.init(t.allocator); defer arena.deinit(); const a = arena.allocator();
const all = try ContentFilter.init(a, false, null, null, null); try t.expect(all.keeps("x", "https://x/bufo.gif"));
const png = try ContentFilter.init(a, false, null, null, " PNG, .jpg "); try t.expect(png.keeps("x", "https://x/bufo.png")); try t.expect(png.keeps("x", "https://x/bufo.PNG")); try t.expect(!png.keeps("x", "https://x/bufo.gif")); try t.expect(!png.keeps("x", "https://x/bufo"));}