Building Domain-Specific Languages (DSLs) — Complete Guide

class QueryBuilder:
    def __init__(self):
        self._table = None
        self._fields = []
        self._conditions = []
        self._order_by = None

    def select(self, *fields):
        self._fields = list(fields)
        return self

    def from_table(self, table):
        self._table = table
        return self

    def where(self, condition):
        self._conditions.append(condition)
        return self

    def order_by(self, field, direction="ASC"):
        self._order_by = f"{field} {direction}"
        return self

    def build(self):
        query = f"SELECT {', '.join(self._fields) if self._fields else '*'}"
        query += f" FROM {self._table}"
        if self._conditions:
            query += " WHERE " + " AND ".join(self._conditions)
        if self._order_by:
            query += f" ORDER BY {self._order_by}"
        query += ";"
        return query

query = (QueryBuilder()
    .select("name", "email", "age")
    .from_table("users")
    .where("age > 18")
    .where("status = 'active'")
    .order_by("name")
    .build())
print(query)

import re

class ConfigDSLLexer:
    tokens = [
        ("IDENTIFIER", r'[a-zA-Z_][a-zA-Z0-9_]*'),
        ("STRING", r'"[^"]*"'),
        ("NUMBER", r'\d+'),
        ("LBRACE", r'\{'),
        ("RBRACE", r'\}'),
        ("SLASH", r'/'),
        ("DOT", r'\.'),
        ("STAR", r'\*'),
        ("NEWLINE", r'\n'),
        ("SKIP", r'[ \t]+'),
    ]

    def __init__(self, source):
        self.source = source
        self.tokens = []
        self.tokenize()

    def tokenize(self):
        pos = 0
        while pos < len(self.source):
            match = None
            for name, pattern in self.tokens:
                regex = re.compile(pattern)
                match = regex.match(self.source, pos)
                if match:
                    text = match.group(0)
                    if name != "SKIP":
                        self.tokens.append((name, text, pos))
                    pos = match.end()
                    break
            if not match:
                raise SyntaxError(f"Unexpected character at position {pos}")

class ConfigDSLParser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.pos = 0
        self.config = {"servers": {}, "routes": [], "firewall": []}

    def parse(self):
        while self.pos < len(self.tokens):
            token = self.tokens[self.pos]
            if token[0] == "IDENTIFIER" and token[1] == "server":
                self.parse_server()
            elif token[0] == "IDENTIFIER" and token[1] == "route":
                self.parse_route()
            elif token[0] == "IDENTIFIER" and token[1] == "firewall":
                self.parse_firewall()
            else:
                self.pos += 1
        return self.config

    def parse_server(self):
        self.pos += 1
        name_token = self.tokens[self.pos]
        name = name_token[1]
        self.pos += 1
        self.expect("LBRACE")
        server = {"host": "", "port": 0, "ssl": False}
        while self.tokens[self.pos][0] != "RBRACE":
            key = self.tokens[self.pos][1]
            self.pos += 1
            val_token = self.tokens[self.pos]
            if val_token[0] == "STRING":
                val = val_token[1].strip('"')
            elif val_token[0] == "NUMBER":
                val = int(val_token[1])
            elif val_token[1] == "true":
                val = True
            elif val_token[1] == "false":
                val = False
            server[key] = val
            self.pos += 1
        self.expect("RBRACE")
        self.config["servers"][name] = server

    def expect(self, token_type):
        if self.tokens[self.pos][0] != token_type:
            raise SyntaxError(f"Expected {token_type}, got {self.tokens[self.pos][1]}")
        self.pos += 1

source = '''
server web-server {
    host "192.168.1.10"
    port 8080
    ssl true
}
'''
lexer = ConfigDSLLexer(source)
parser = ConfigDSLParser(lexer.tokens)
config = parser.parse()
for name, settings in config["servers"].items():
    print(f"Server: {name}")
    for key, val in settings.items():
        print(f"  {key}: {val}")

class DSLCodeGenerator:
    def generate(self, config):
        code = []
        code.append("# Generated configuration")
        code.append("")
        for name, settings in config["servers"].items():
            code.append(f"class {name.capitalize()}Server:")
            for key, val in settings.items():
                code.append(f"    {key} = {repr(val)}")
            code.append("")
        return "\n".join(code)

generator = DSLCodeGenerator()
print(generator.generate(config))