modelable 1.0.0__py3-none-any.whl

modelable/lsp/definition.py

@@ -0,0 +1,343 @@
+from __future__ import annotations
+
+import re
+
+from lsprotocol import types
+
+from modelable.llm.context import parse_model_ref
+from modelable.lsp.workspace import LspWorkspaceIndex
+from modelable.registry.resolver import resolve_model_ref
+
+_QUALIFIED_REF_PATTERN = re.compile(
+    r"(?P<domain>[A-Za-z_][A-Za-z0-9_]*)\.(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*@\s*(?P<version>\d+)"
+)
+_REF_TYPE_PATTERN = re.compile(r"ref\s*<\s*(?P<domain>[A-Za-z_][A-Za-z0-9_]*)\.(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*>")
+_FIELD_REF_PATTERN = re.compile(r"(?P<alias>[A-Za-z_][A-Za-z0-9_]*)\.(?P<field>[A-Za-z_][A-Za-z0-9_]*)")
+_DECL_PATTERN = re.compile(
+    r"^\s*(?P<kind>entity|aggregate|event|value|projection)\s+"
+    r"(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*@\s*(?P<version>\d+)"
+)
+_DOMAIN_PATTERN = re.compile(r'^\s*domain\s+(?:"(?P<quoted>[^"]+)"|(?P<name>[A-Za-z_][A-Za-z0-9_]*))')
+_WORD_PATTERN = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
+_MODEL_FIELD_PATTERN = re.compile(
+    r"^\s*(?:@[A-Za-z_][A-Za-z0-9_]*(?:\([^)]*\))?\s+)*(?P<name>[A-Za-z_][A-Za-z0-9_]*)\??\s*:"
+)
+_PROJECTION_FIELD_PATTERN = re.compile(
+    r"^\s*(?:@[A-Za-z_][A-Za-z0-9_]*(?:\([^)]*\))?\s+)*(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*(?:<-|=)"
+)
+
+
+_MODEL_DECL_KINDS = {"entity", "aggregate", "event", "value"}
+
+
+def build_definition(
+    index: LspWorkspaceIndex, uri: str, line: int, character: int
+) -> types.Location | list[types.Location] | None:
+    source = index.documents.get(uri)
+    workspace = index.workspace
+    if source is None or workspace is None:
+        return None
+
+    lines = source.text.splitlines()
+    if line < 0 or line >= len(lines):
+        return None
+    text_line = lines[line]
+
+    for match in _QUALIFIED_REF_PATTERN.finditer(text_line):
+        if _contains(match.start(), match.end(), character):
+            ref = f"{match.group('domain')}.{match.group('name')}@{match.group('version')}"
+            location = _definition_for_qualified_ref(workspace, ref)
+            if location is not None:
+                return location
+
+    for match in _REF_TYPE_PATTERN.finditer(text_line):
+        if _contains(match.start(), match.end(), character):
+            location = _definition_for_unversioned_ref(workspace, match.group("domain"), match.group("name"))
+            if location is not None:
+                return location
+
+    for match in _FIELD_REF_PATTERN.finditer(text_line):
+        if _contains(match.start(), match.end(), character):
+            location = _definition_for_field_reference(
+                workspace,
+                source.text,
+                line,
+                match.group("alias"),
+                match.group("field"),
+            )
+            if location is not None:
+                return location
+
+    word = _word_at(text_line, character)
+    if word is None:
+        return None
+
+    scope = _current_scope(source.text, line)
+    if scope is None:
+        return None
+    domain_name, kind, name, version = scope
+
+    if word == name:
+        return _definition_for_decl(workspace, domain_name, kind, name, version)
+
+    if kind == "model":
+        return _definition_for_model_field(
+            workspace,
+            domain_name,
+            name,
+            version,
+            word,
+        )
+    return _definition_for_projection_field(
+        workspace,
+        domain_name,
+        name,
+        version,
+        word,
+    )
+
+
+def _definition_for_qualified_ref(workspace, ref: str) -> types.Location | None:
+    model_ref = parse_model_ref(ref)
+    domain = next((d for d in workspace.mdl.domains if d.name == model_ref.domain), None)
+    if domain is None:
+        return None
+    if model_ref.name in domain.models:
+        return _definition_for_decl(workspace, model_ref.domain, "model", model_ref.name, model_ref.version)
+    if model_ref.name in domain.projections:
+        return _definition_for_decl(workspace, model_ref.domain, "projection", model_ref.name, model_ref.version)
+    return None
+
+
+def _definition_for_unversioned_ref(workspace, domain_name: str, name: str) -> types.Location | None:
+    domain = next((d for d in workspace.mdl.domains if d.name == domain_name), None)
+    if domain is None:
+        return None
+    if name in domain.models:
+        latest = max(domain.models[name], key=lambda v: v.version)
+        return _definition_for_decl(workspace, domain_name, "model", name, latest.version)
+    if name in domain.projections:
+        latest = max(domain.projections[name], key=lambda v: v.version)
+        return _definition_for_decl(workspace, domain_name, "projection", name, latest.version)
+    return None
+
+
+def _definition_for_field_reference(
+    workspace,
+    text: str,
+    line: int,
+    alias: str,
+    field_name: str,
+) -> types.Location | None:
+    scope = _current_scope(text, line)
+    if scope is None:
+        return None
+    domain_name, kind, name, version = scope
+    if kind == "model":
+        return _definition_for_model_field(workspace, domain_name, name, version, field_name)
+
+    domain = next((d for d in workspace.mdl.domains if d.name == domain_name), None)
+    if domain is None:
+        return None
+    versions = domain.projections.get(name)
+    if not versions:
+        return None
+    projection_version = next((item for item in versions if item.version == version), None)
+    if projection_version is None:
+        return None
+
+    for source_ref in [projection_version.source, *projection_version.joins]:
+        if source_ref.alias != alias:
+            continue
+        try:
+            resolved = resolve_model_ref(
+                workspace.mdl,
+                source_ref.model,
+                source_ref.version,
+            )
+        except LookupError:
+            break
+        return _definition_for_source_field(
+            workspace,
+            resolved.domain_name,
+            resolved.model_name,
+            resolved.version.version,
+            field_name,
+        )
+
+    return _definition_for_projection_field(workspace, domain_name, name, version, field_name)
+
+
+def _definition_for_decl(
+    workspace,
+    domain_name: str,
+    kind: str,
+    name: str,
+    version: int,
+) -> types.Location | None:
+    for source in workspace.sources:
+        location = _find_decl_location(source.uri, source.text, domain_name, kind, name, version)
+        if location is not None:
+            return location
+    return None
+
+
+def _definition_for_model_field(
+    workspace,
+    domain_name: str,
+    model_name: str,
+    version: int,
+    field_name: str,
+) -> types.Location | None:
+    return _definition_for_source_field(workspace, domain_name, model_name, version, field_name)
+
+
+def _definition_for_source_field(
+    workspace,
+    domain_name: str,
+    model_name: str,
+    version: int,
+    field_name: str,
+) -> types.Location | None:
+    for source in workspace.sources:
+        for kind in ("model", "projection"):
+            location = _find_field_location(
+                source.uri,
+                source.text,
+                domain_name,
+                kind,
+                model_name,
+                version,
+                field_name,
+            )
+            if location is not None:
+                return location
+    return None
+
+
+def _definition_for_projection_field(
+    workspace,
+    domain_name: str,
+    projection_name: str,
+    version: int,
+    field_name: str,
+) -> types.Location | None:
+    return _definition_for_source_field(workspace, domain_name, projection_name, version, field_name)
+
+
+def _find_decl_location(
+    uri: str,
+    text: str,
+    domain_name: str,
+    kind: str,
+    name: str,
+    version: int,
+) -> types.Location | None:
+    current_domain: str | None = None
+    lines = text.splitlines()
+    for line_no, line in enumerate(lines):
+        domain_match = _DOMAIN_PATTERN.match(line)
+        if domain_match:
+            current_domain = domain_match.group("quoted") or domain_match.group("name")
+            continue
+        decl_match = _DECL_PATTERN.match(line)
+        if not decl_match or current_domain != domain_name:
+            continue
+        decl_kind = decl_match.group("kind")
+        if kind == "model":
+            if decl_kind not in _MODEL_DECL_KINDS:
+                continue
+        elif decl_kind != kind:
+            continue
+        if decl_match.group("name") != name:
+            continue
+        if int(decl_match.group("version")) != version:
+            continue
+        return types.Location(
+            uri=uri,
+            range=types.Range(
+                start=types.Position(line=line_no, character=decl_match.start("name")),
+                end=types.Position(line=line_no, character=decl_match.end("name")),
+            ),
+        )
+    return None
+
+
+def _find_field_location(
+    uri: str,
+    text: str,
+    domain_name: str,
+    kind: str,
+    name: str,
+    version: int,
+    field_name: str,
+) -> types.Location | None:
+    current_domain: str | None = None
+    active = False
+    lines = text.splitlines()
+    pattern = _MODEL_FIELD_PATTERN if kind == "model" else _PROJECTION_FIELD_PATTERN
+
+    for line_no, line in enumerate(lines):
+        domain_match = _DOMAIN_PATTERN.match(line)
+        if domain_match:
+            current_domain = domain_match.group("quoted") or domain_match.group("name")
+            active = False
+            continue
+        decl_match = _DECL_PATTERN.match(line)
+        if decl_match and current_domain == domain_name:
+            decl_kind = decl_match.group("kind")
+            active = (
+                (decl_kind in _MODEL_DECL_KINDS if kind == "model" else decl_kind == kind)
+                and decl_match.group("name") == name
+                and int(decl_match.group("version")) == version
+            )
+            continue
+        if not active:
+            continue
+        field_match = pattern.match(line)
+        if field_match and field_match.group("name") == field_name:
+            return types.Location(
+                uri=uri,
+                range=types.Range(
+                    start=types.Position(line=line_no, character=field_match.start("name")),
+                    end=types.Position(line=line_no, character=field_match.end("name")),
+                ),
+            )
+        if line.strip() == "}":
+            active = False
+    return None
+
+
+def _current_scope(text: str, line: int) -> tuple[str, str, str, int] | None:
+    lines = text.splitlines()
+    current_domain: str | None = None
+    current_kind: str | None = None
+    current_name: str | None = None
+    current_version: int | None = None
+    for item in lines[: line + 1]:
+        domain_match = _DOMAIN_PATTERN.match(item)
+        if domain_match:
+            current_domain = domain_match.group("quoted") or domain_match.group("name")
+            current_kind = None
+            current_name = None
+            current_version = None
+            continue
+        decl_match = _DECL_PATTERN.match(item)
+        if decl_match and current_domain is not None:
+            current_kind = "model" if decl_match.group("kind") != "projection" else "projection"
+            current_name = decl_match.group("name")
+            current_version = int(decl_match.group("version"))
+    if current_domain and current_kind and current_name and current_version is not None:
+        return current_domain, current_kind, current_name, current_version
+    return None
+
+
+def _word_at(text_line: str, character: int) -> str | None:
+    for match in _WORD_PATTERN.finditer(text_line):
+        if _contains(match.start(), match.end(), character):
+            return match.group(0)
+    return None
+
+
+def _contains(start: int, end: int, character: int) -> bool:
+    return start <= character <= max(end - 1, start)

modelable/lsp/diagnostics.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from lsprotocol import types
+
+from modelable.diagnostics.model import Diagnostic
+
+
+def to_lsp_diagnostic(diagnostic: Diagnostic) -> types.Diagnostic:
+    severity_map = {
+        "error": types.DiagnosticSeverity.Error,
+        "warning": types.DiagnosticSeverity.Warning,
+        "information": types.DiagnosticSeverity.Information,
+    }
+    line = max((diagnostic.line or 1) - 1, 0)
+    column = max((diagnostic.column or 1) - 1, 0)
+    end_line = max((diagnostic.end_line or diagnostic.line or 1) - 1, 0)
+    end_column = max((diagnostic.end_column or diagnostic.column or 1) - 1, 0)
+    return types.Diagnostic(
+        message=diagnostic.message,
+        severity=severity_map[diagnostic.severity],
+        source="modelable",
+        code=diagnostic.code,
+        range=types.Range(
+            start=types.Position(line=line, character=column),
+            end=types.Position(line=end_line, character=end_column),
+        ),
+    )
+
+
+def to_lsp_diagnostics(diagnostics: list[Diagnostic]) -> list[types.Diagnostic]:
+    return [to_lsp_diagnostic(diagnostic) for diagnostic in diagnostics]

modelable/lsp/document_symbols.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import re
+
+from lsprotocol import types
+
+from modelable.lsp.workspace import LspWorkspaceIndex
+
+_DOMAIN_PATTERN = re.compile(r'^\s*domain\s+(?:"(?P<quoted>[^"]+)"|(?P<name>[A-Za-z_][A-Za-z0-9_]*))')
+_DECL_PATTERN = re.compile(
+    r"^\s*(?P<kind>entity|aggregate|event|value|projection)\s+"
+    r"(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*@\s*(?P<version>\d+)"
+)
+_FIELD_PATTERN = re.compile(r"^\s*(?:@[A-Za-z_][A-Za-z0-9_]*(?:\([^)]*\))?\s+)*(?P<name>[A-Za-z_][A-Za-z0-9_]*)\??\s*:")
+_PROJECTION_FIELD_PATTERN = re.compile(
+    r"^\s*(?:@[A-Za-z_][A-Za-z0-9_]*(?:\([^)]*\))?\s+)*(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*(?:<-|=)"
+)
+
+
+def build_document_symbols(
+    index: LspWorkspaceIndex,
+    uri: str,
+) -> list[types.DocumentSymbol] | None:
+    source = index.documents.get(uri)
+    if source is None or index.workspace is None:
+        return None
+
+    lines = source.text.splitlines()
+    symbols: list[types.DocumentSymbol] = []
+    current_domain: types.DocumentSymbol | None = None
+    current_decl: types.DocumentSymbol | None = None
+    current_domain_name: str | None = None
+    current_decl_name: str | None = None
+    current_decl_kind: str | None = None
+    current_decl_version: int | None = None
+
+    for line_no, line in enumerate(lines):
+        domain_match = _DOMAIN_PATTERN.match(line)
+        if domain_match:
+            current_domain_name = domain_match.group("quoted") or domain_match.group("name")
+            current_domain = _make_domain_symbol(
+                lines,
+                line_no,
+                current_domain_name,
+            )
+            symbols.append(current_domain)
+            current_decl = None
+            current_decl_name = None
+            current_decl_kind = None
+            current_decl_version = None
+            continue
+
+        decl_match = _DECL_PATTERN.match(line)
+        if decl_match and current_domain is not None and current_domain_name is not None:
+            current_decl_name = decl_match.group("name")
+            current_decl_kind = decl_match.group("kind")
+            current_decl_version = int(decl_match.group("version"))
+            current_decl = _make_decl_symbol(
+                lines,
+                line_no,
+                current_domain_name,
+                current_decl_kind,
+                current_decl_name,
+                current_decl_version,
+            )
+            if current_domain.children is None:
+                current_domain.children = [current_decl]
+            else:
+                current_domain.children = [*current_domain.children, current_decl]
+            continue
+
+        if current_decl is None:
+            continue
+
+        field_match = _FIELD_PATTERN.match(line) or _PROJECTION_FIELD_PATTERN.match(line)
+        if field_match:
+            field_symbol = _make_field_symbol(
+                line_no,
+                field_match.start("name"),
+                field_match.end("name"),
+                field_match.group("name"),
+                line,
+            )
+            if current_decl.children is None:
+                current_decl.children = [field_symbol]
+            else:
+                current_decl.children = [*current_decl.children, field_symbol]
+
+    return symbols
+
+
+def _make_domain_symbol(
+    lines: list[str],
+    line_no: int,
+    name: str,
+) -> types.DocumentSymbol:
+    return types.DocumentSymbol(
+        name=name,
+        kind=types.SymbolKind.Module,
+        detail="domain",
+        range=types.Range(
+            start=types.Position(line=line_no, character=0),
+            end=types.Position(
+                line=_block_end_line(lines, line_no), character=len(lines[_block_end_line(lines, line_no)])
+            ),
+        ),
+        selection_range=types.Range(
+            start=types.Position(line=line_no, character=_domain_name_start(lines[line_no])),
+            end=types.Position(line=line_no, character=_domain_name_end(lines[line_no])),
+        ),
+    )
+
+
+def _make_decl_symbol(
+    lines: list[str],
+    line_no: int,
+    domain_name: str,
+    kind: str,
+    name: str,
+    version: int,
+) -> types.DocumentSymbol:
+    detail = f"{kind} @{version}"
+    return types.DocumentSymbol(
+        name=name,
+        kind=types.SymbolKind.Class,
+        detail=detail,
+        range=types.Range(
+            start=types.Position(line=line_no, character=0),
+            end=types.Position(
+                line=_block_end_line(lines, line_no), character=len(lines[_block_end_line(lines, line_no)])
+            ),
+        ),
+        selection_range=types.Range(
+            start=types.Position(line=line_no, character=_decl_name_start(lines[line_no])),
+            end=types.Position(line=line_no, character=_decl_name_end(lines[line_no])),
+        ),
+    )
+
+
+def _make_field_symbol(
+    line_no: int,
+    start: int,
+    end: int,
+    name: str,
+    line: str,
+) -> types.DocumentSymbol:
+    return types.DocumentSymbol(
+        name=name,
+        kind=types.SymbolKind.Field,
+        detail=line.strip(),
+        range=types.Range(
+            start=types.Position(line=line_no, character=0),
+            end=types.Position(line=line_no, character=len(line)),
+        ),
+        selection_range=types.Range(
+            start=types.Position(line=line_no, character=start),
+            end=types.Position(line=line_no, character=end),
+        ),
+    )
+
+
+def _block_end_line(lines: list[str], start_line: int) -> int:
+    depth = 0
+    for line_no in range(start_line, len(lines)):
+        depth += lines[line_no].count("{")
+        depth -= lines[line_no].count("}")
+        if line_no > start_line and depth <= 0:
+            return line_no
+    return max(len(lines) - 1, start_line)
+
+
+def _domain_name_start(line: str) -> int:
+    match = _DOMAIN_PATTERN.match(line)
+    if match is None:
+        return 0
+    return match.start("quoted") if match.group("quoted") is not None else match.start("name")
+
+
+def _domain_name_end(line: str) -> int:
+    match = _DOMAIN_PATTERN.match(line)
+    if match is None:
+        return 0
+    return match.end("quoted") if match.group("quoted") is not None else match.end("name")
+
+
+def _decl_name_start(line: str) -> int:
+    match = _DECL_PATTERN.match(line)
+    if match is None:
+        return 0
+    return match.start("name")
+
+
+def _decl_name_end(line: str) -> int:
+    match = _DECL_PATTERN.match(line)
+    if match is None:
+        return 0
+    return match.end("name")