# Custom Blocking Rules Compiler

> Use when compiling custom blocking rules.

- Skill: `loopyluci/custom-blocking-rules-compiler` (Agent Skill)
- Install (CLI): `npx skillmds@latest add loopyluci/custom-blocking-rules-compiler`
- Raw SKILL.md: https://api.skillmd.com/api/skills/loopyluci/custom-blocking-rules-compiler/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: LoopyLuci (https://skillmd.com/u/loopyluci)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/loopyluci/custom-blocking-rules-compiler

---


# Custom Blocking Rules Compiler

Compiling custom blocking rules for adblocking, firewall, and content filtering — from rule parsing and optimization through compiled rule formats and performance tuning.

## When to Use

- Building custom adblock or content filter rule sets
- Converting rules between formats (ABP → uBlock, Surge, Pi-hole)
- Optimizing rule matching performance with data structures
- Compiling human-readable rules into efficient matching formats

## Rule Compilation

```python
import re
from typing import List, Dict

class BlockingRule:
    """A single blocking rule in ABP/adblock format."""
    def __init__(self, pattern: str, options: Dict = None):
        self.pattern = pattern  # e.g., ||example.com/ads/*
        self.options = options or {}
        self.type = self._detect_type()
    
    def _detect_type(self) -> str:
        if self.pattern.startswith('||'): return 'domain'
        if self.pattern.startswith('|'): return 'exact_prefix'
        if self.pattern.endswith('|'): return 'exact_suffix'
        if '*' in self.pattern: return 'wildcard'
        if self.pattern.startswith('/') and self.pattern.endswith('/'): return 'regex'
        return 'substring'

class RuleCompiler:
    """Compile blocking rules into optimized matching structures."""
    def __init__(self):
        self.rules = []
    
    def add_rules(self, rules_text: str):
        for line in rules_text.strip().split('\n'):
            line = line.strip()
            if line and not line.startswith('!'):
                self.rules.append(BlockingRule(line))
    
    def compile_to_bloom(self) -> Dict:
        """Convert rules to bloom filter for fast pre-filtering."""
        domains = [r.pattern[2:] for r in self.rules if r.type == 'domain']
        return {'domains': domains, 'count': len(domains)}
    
    def optimize(self) -> int:
        """Merge and deduplicate rules."""
        patterns = set(r.pattern for r in self.rules)
        self.rules = [BlockingRule(p) for p in patterns]
        return len(self.rules)
```

## Verification Checklist

- [ ] Rules parsed from ABP-compatible format
- [ ] Rule types detected correctly (domain, wildcard, regex, exact)
- [ ] Rules compiled into optimized matching structure
- [ ] Deduplication and merging applied
- [ ] Performance benchmarked (rules/sec matching)
- [ ] False positive rate measured
- [ ] Export format supports target platform (Pi-hole, uBlock, AdGuard)