coom-lang 0.0.1a1__tar.gz

coom_lang-0.0.1a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 denkbares GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

coom_lang-0.0.1a1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: coom-lang
+Version: 0.0.1a1
+Summary: Parser, compiler and writer of the COOM product configuration language
+Keywords: coom,product configuration,dsl,parser,compiler
+Author: denkbares GmbH
+Author-email: denkbares GmbH <info@denkbares.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: coom-core==0.0.1a1
+Requires-Dist: antlr4-python3-runtime==4.13.2
+Requires-Python: >=3.12
+Project-URL: Homepage, https://www.coom-lang.org
+Project-URL: Repository, https://github.com/denkbares/coom-lang
+Project-URL: Changelog, https://github.com/denkbares/coom-lang/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# coom-lang
+
+Parser, compiler and writer of the [COOM](https://www.coom-lang.org) product configuration language.
+
+```python
+from coom.compiler import compile_files
+
+result = compile_files(["Bike.model"])
+for diagnostic in result.diagnostics:
+    print(diagnostic)
+model = result.model
+```
+
+The compiled model is the one of `coom-core`. Sources live in the
+[coom-lang repository](https://github.com/denkbares/coom-lang) under `packages/coom-lang`.

coom_lang-0.0.1a1/README.md

@@ -0,0 +1,15 @@
+# coom-lang
+
+Parser, compiler and writer of the [COOM](https://www.coom-lang.org) product configuration language.
+
+```python
+from coom.compiler import compile_files
+
+result = compile_files(["Bike.model"])
+for diagnostic in result.diagnostics:
+    print(diagnostic)
+model = result.model
+```
+
+The compiled model is the one of `coom-core`. Sources live in the
+[coom-lang repository](https://github.com/denkbares/coom-lang) under `packages/coom-lang`.

coom_lang-0.0.1a1/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["uv_build>=0.13.6,<0.14"]
+build-backend = "uv_build"
+
+[project]
+name = "coom-lang"
+version = "0.0.1a1"
+description = "Parser, compiler and writer of the COOM product configuration language"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+keywords = [
+    "coom",
+    "product configuration",
+    "dsl",
+    "parser",
+    "compiler",
+]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "coom-core==0.0.1a1",
+    "antlr4-python3-runtime==4.13.2",
+]
+
+[[project.authors]]
+name = "denkbares GmbH"
+email = "info@denkbares.com"
+
+[project.urls]
+Homepage = "https://www.coom-lang.org"
+Repository = "https://github.com/denkbares/coom-lang"
+Changelog = "https://github.com/denkbares/coom-lang/blob/main/CHANGELOG.md"
+
+[tool.uv.build-backend]
+module-name = [
+    "coom.parser",
+    "coom.compiler",
+    "coom.writer",
+]
+
+[tool.uv.sources.coom-core]
+workspace = true

coom_lang-0.0.1a1/pyproject.toml.orig

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["uv_build>=0.13.6,<0.14"]
+build-backend = "uv_build"
+
+[project]
+name = "coom-lang"
+version = "0.0.1a1"
+description = "Parser, compiler and writer of the COOM product configuration language"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [{ name = "denkbares GmbH", email = "info@denkbares.com" }]
+keywords = ["coom", "product configuration", "dsl", "parser", "compiler"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "coom-core==0.0.1a1",
+    "antlr4-python3-runtime==4.13.2",
+]
+
+[project.urls]
+Homepage = "https://www.coom-lang.org"
+Repository = "https://github.com/denkbares/coom-lang"
+Changelog = "https://github.com/denkbares/coom-lang/blob/main/CHANGELOG.md"
+
+[tool.uv.build-backend]
+module-name = ["coom.parser", "coom.compiler", "coom.writer"]
+
+[tool.uv.sources]
+coom-core = { workspace = true }

coom_lang-0.0.1a1/src/coom/compiler/__init__.py

@@ -0,0 +1,61 @@
+"""Compiles parse trees into a model and reports the errors it finds with their source positions.
+
+The compiler resolves names and builds the model graph, then runs the static checks of coom.check on it. It continues
+after errors, leaving out the statements that contain them, so tools still get a model.
+"""
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+
+from coom.check import check
+from coom.compiler._behaviors import compile_behaviors
+from coom.compiler._context import Compilation
+from coom.compiler._declarations import assign_attribute_values, declare_fields, declare_types
+from coom.compiler._testing import compile_tests
+from coom.diagnostics import Diagnostic, Severity
+from coom.model import Model
+from coom.parser import ParseResult, parse, parse_file
+
+__all__ = ["CompileResult", "compile", "compile_files", "compile_text"]
+
+# Each phase runs over all sources before the next one starts, so declarations may refer to any type in any source.
+_PHASES = (declare_types, declare_fields, assign_attribute_values, compile_behaviors, compile_tests)
+
+
+@dataclass(frozen=True, slots=True)
+class CompileResult:
+    model: Model
+    diagnostics: tuple[Diagnostic, ...]
+    """The syntax errors of all sources, then the errors of compilation, then those of the static checks."""
+
+    @property
+    def ok(self) -> bool:
+        return not any(diagnostic.severity is Severity.ERROR for diagnostic in self.diagnostics)
+
+
+def compile(*sources: ParseResult, checks: bool = True) -> CompileResult:
+    """Compiles the parse results of one or more sources that together form one model."""
+    compilation = Compilation()
+    for phase in _PHASES:
+        for source in sources:
+            compilation.source = source.source
+            phase(compilation, source.tree)
+    model = Model(
+        root=compilation.root,
+        structures=tuple(compilation.structures),
+        enumerations=tuple(compilation.enumerations),
+        behaviors=tuple(compilation.behaviors),
+        tests=tuple(compilation.tests),
+    )
+    syntax = tuple(diagnostic for source in sources for diagnostic in source.diagnostics)
+    checked = check(model) if checks else ()
+    return CompileResult(model, (*syntax, *compilation.diagnostics, *checked))
+
+
+def compile_text(text: str, *, source: str | None = None) -> CompileResult:
+    return compile(parse(text, source=source))
+
+
+def compile_files(paths: Iterable[str | Path]) -> CompileResult:
+    return compile(*(parse_file(path) for path in paths))

coom_lang-0.0.1a1/src/coom/compiler/_behaviors.py

@@ -0,0 +1,252 @@
+"""The phase that compiles behavior blocks into flat behaviors.
+
+Definitions are substituted, preconditions of enclosing blocks are collected into each statement, and derivation
+tables are lowered to one require or default per row and column.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from dataclasses import dataclass
+from typing import Any, TypedDict
+
+from coom.compiler._context import Abort, Compilation, children, name, need, unquote
+from coom.compiler._expressions import Expressions, Scope
+from coom.model import (
+    AttributeStep,
+    Cell,
+    CellAtom,
+    Combinations,
+    CompareOp,
+    Condition,
+    Default,
+    Direction,
+    Directive,
+    Enumeration,
+    Formula,
+    Imply,
+    Optimize,
+    Or,
+    PathAccess,
+    Require,
+    Row,
+    RowKind,
+    Span,
+    Structure,
+    Visibility,
+    value_type,
+)
+from coom.parser._antlr.COOMParser import COOMParser
+
+
+def compile_behaviors(compilation: Compilation, tree: Any) -> None:
+    for node in children(tree):
+        if isinstance(node, COOMParser.BehaviorContext):
+            try:
+                origin = resolve_origin(compilation, node.name())
+                block = need(node.behavior_block())
+            except Abort:
+                continue
+            _Block(compilation, Expressions(compilation, origin)).block(block, Scope.of(compilation, origin), _Frame())
+
+
+def resolve_origin(compilation: Compilation, node: Any) -> Structure:
+    """Returns the structure a behavior or test block names, the product if it names none."""
+    if node is None:
+        return compilation.root
+    type_name = name(node)
+    type_ = compilation.types.get(type_name)
+    if type_ is None:
+        compilation.fail(node, f"the structure {type_name} is not defined")
+    if not isinstance(type_, Structure):
+        compilation.fail(node, f"{type_name} is an enumeration, not a structure")
+    return type_
+
+
+@dataclass(frozen=True, slots=True)
+class _Frame:
+    """What a statement inherits from its enclosing blocks."""
+
+    conditions: tuple[Condition, ...] = ()
+    explanation: str | None = None
+
+
+class _Common(TypedDict):
+    origin: Structure
+    conditions: tuple[Condition, ...]
+    explanation: str | None
+    span: Span
+
+
+class _Block:
+    def __init__(self, compilation: Compilation, expressions: Expressions) -> None:
+        self.compilation = compilation
+        self.expressions = expressions
+        self.origin = expressions.origin
+
+    def block(self, node: Any, scope: Scope, frame: _Frame) -> None:
+        for definition in node.define():
+            try:
+                formula = self.expressions.formula(definition.formula(), scope)
+                scope = scope.define(name(definition.name()), formula)
+            except Abort:
+                pass
+        for statement in node.conditioned():
+            with contextlib.suppress(Abort):
+                self.conditioned(statement, scope, frame)
+
+    def conditioned(self, node: Any, scope: Scope, frame: _Frame) -> None:
+        explanation = frame.explanation
+        if node.explanation() is not None:
+            explanation = unquote(need(node.explanation().name()).getText())
+        preconditions = tuple(self.expressions.condition(p.condition(), scope) for p in node.precondition())
+        frame = _Frame((*frame.conditions, *preconditions), explanation)
+        if node.behavior_block() is not None:
+            self.block(node.behavior_block(), scope, frame)
+        elif node.require() is not None:
+            self._require(node.require(), scope, frame)
+        elif node.assign_imply() is not None:
+            self._imply(node.assign_imply(), scope, frame)
+        elif node.assign_default() is not None:
+            self._default(node.assign_default(), scope, frame)
+        elif node.optimize() is not None:
+            self._optimize(node.optimize(), scope, frame)
+        elif node.visibility() is not None:
+            self._visibility(node.visibility(), scope, frame)
+        elif node.combinations() is not None:
+            self._combinations(node.combinations(), scope, frame)
+        elif node.derivation_table() is not None:
+            self._derivation_table(node.derivation_table(), scope, frame)
+
+    def _common(self, node: Any, frame: _Frame) -> _Common:
+        return _Common(
+            origin=self.origin,
+            conditions=frame.conditions,
+            explanation=frame.explanation,
+            span=self.compilation.span(node),
+        )
+
+    def _require(self, node: Any, scope: Scope, frame: _Frame) -> None:
+        condition = self.expressions.condition(node.condition(), scope)
+        self.compilation.behaviors.append(Require(condition=condition, **self._common(node, frame)))
+
+    def _imply(self, node: Any, scope: Scope, frame: _Frame) -> None:
+        target = self.expressions.assignable(node.path(), scope)
+        value = self.expressions.formula(node.formula(), scope.expecting(target.type))
+        self.compilation.behaviors.append(Imply(target=target, value=value, **self._common(node, frame)))
+
+    def _default(self, node: Any, scope: Scope, frame: _Frame) -> None:
+        priority = None
+        if node.priority is not None:
+            priority = int(node.priority.text)
+            if priority < 1:
+                self.compilation.fail(node.priority, "the priority must be at least 1")
+        target = self.expressions.assignable(node.path(), scope)
+        value = self.expressions.formula(node.formula(), scope.expecting(target.type))
+        self.compilation.behaviors.append(
+            Default(target=target, value=value, priority=priority, **self._common(node, frame))
+        )
+
+    def _optimize(self, node: Any, scope: Scope, frame: _Frame) -> None:
+        target = self.expressions.assignable(node.path(), scope)
+        direction = Direction(need(node.kw).text)
+        self.compilation.behaviors.append(Optimize(direction=direction, target=target, **self._common(node, frame)))
+
+    def _visibility(self, node: Any, scope: Scope, frame: _Frame) -> None:
+        directive = Directive(need(node.directive).text)
+        target = self.expressions.assignable(node.path(), scope)
+        options = []
+        if node.name():
+            enumeration = target.type
+            if not isinstance(enumeration, Enumeration):
+                self.compilation.fail(node.path(), "only options of an enumeration can be hidden individually")
+            if directive is not Directive.HIDE:
+                self.compilation.fail(node.directive, "options can only be hidden, not made read only")
+            for option_node in node.name():
+                try:
+                    option = enumeration.option(name(option_node))
+                except KeyError:
+                    self.compilation.fail(
+                        option_node, f"{option_node.getText()} is not an option of {enumeration.name}"
+                    )
+                if option not in options:
+                    options.append(option)
+            if len(options) == len(enumeration.options):
+                self.compilation.fail(node, f"cannot hide all options of {enumeration.name}")
+        self.compilation.behaviors.append(
+            Visibility(directive=directive, target=target, options=tuple(options), **self._common(node, frame))
+        )
+
+    def _combinations(self, node: Any, scope: Scope, frame: _Frame) -> None:
+        if not node.combination_row():
+            self.compilation.fail(node.kw, "a combinations table needs at least one row")
+        columns = tuple(self.expressions.formula(column, scope) for column in node.formula())
+        rows = []
+        for row_node in node.combination_row():
+            items = row_node.combination_item()
+            if len(items) != len(columns):
+                self.compilation.error(row_node, f"the row has {len(items)} cells for {len(columns)} columns")
+                continue
+            try:
+                cells = tuple(self._cell(column, item, scope) for column, item in zip(columns, items, strict=True))
+            except Abort:
+                continue
+            kind = RowKind(need(row_node.rowType).text)
+            rows.append(Row(kind, cells, span=self.compilation.span(row_node)))
+        self.compilation.behaviors.append(Combinations(columns=columns, rows=tuple(rows), **self._common(node, frame)))
+
+    def _cell(self, column: Any, node: Any, scope: Scope) -> Cell | None:
+        if node.any_ is not None:
+            return None
+        cell_scope = scope.expecting(value_type(column))
+        atoms = []
+        for atom in node.combination_atom():
+            value = self.expressions.formula(atom.formula(), cell_scope)
+            operator = CompareOp.EQ if atom.operator is None else CompareOp(atom.operator.getText())
+            atoms.append(CellAtom(value, operator, span=self.compilation.span(atom)))
+        return tuple(atoms)
+
+    def _derivation_table(self, node: Any, scope: Scope, frame: _Frame) -> None:
+        kind = need(node.kw).text
+        targets = tuple(self.expressions.formula(f, scope) for f in need(node.assignment_columns).formula())
+        columns: tuple[Formula, ...] = ()
+        if node.condition_columns is not None:
+            columns = tuple(self.expressions.formula(f, scope) for f in node.condition_columns.formula())
+        if kind == "default":
+            for target, target_node in zip(targets, node.assignment_columns.formula(), strict=True):
+                path = target.path if isinstance(target, PathAccess) else None
+                if path is None or not path.steps or isinstance(path.steps[-1], AttributeStep):
+                    self.compilation.fail(target_node, "a column of a default table must be a path to a feature")
+        for row in node.derivation_table_row():
+            with contextlib.suppress(Abort):
+                self._derivation_row(kind, targets, columns, row, scope, frame)
+
+    def _derivation_row(
+        self, kind: str, targets: tuple[Any, ...], columns: tuple[Any, ...], node: Any, scope: Scope, frame: _Frame
+    ) -> None:
+        cells = node.derivation_condition_cell()
+        values = node.derivation_table_atom()
+        if len(cells) != len(columns):
+            self.compilation.fail(node, f"the row has {len(cells)} condition cells for {len(columns)} columns")
+        if len(values) != len(targets):
+            self.compilation.fail(node, f"the row has {len(values)} values for {len(targets)} columns")
+        # A row reads as a set of statements that share the conditions of its cells, a cell holding if any atom holds.
+        conditions = list(frame.conditions)
+        for column, cell in zip(columns, cells, strict=True):
+            if cell.any_ is not None or not cell.derivation_table_atom():
+                continue
+            atoms = tuple(
+                self.expressions.compare_cell(column, atom.operator, atom.formula(), scope)
+                for atom in cell.derivation_table_atom()
+            )
+            conditions.append(atoms[0] if len(atoms) == 1 else Or(atoms, span=self.compilation.span(cell)))
+        common = self._common(node, _Frame(tuple(conditions), frame.explanation))
+        for target, value_node in zip(targets, values, strict=True):
+            compare = self.expressions.compare_cell(target, value_node.operator, value_node.formula(), scope)
+            if kind == "require":
+                self.compilation.behaviors.append(Require(condition=compare, **common))
+            elif compare.op is not CompareOp.EQ:
+                self.compilation.fail(value_node, "a default table only assigns values with =")
+            else:
+                assert isinstance(target, PathAccess)
+                self.compilation.behaviors.append(Default(target=target.path, value=compare.right, **common))

coom_lang-0.0.1a1/src/coom/compiler/_context.py

@@ -0,0 +1,83 @@
+"""State shared by the compiler phases and helpers to report errors at parse tree positions."""
+
+import re
+from dataclasses import dataclass, field
+from typing import Any, NoReturn
+
+from antlr4 import ParserRuleContext
+from antlr4.tree.Tree import ErrorNode
+
+from coom.diagnostics import Diagnostic, Severity
+from coom.model import ROOT_NAME, Behavior, Enumeration, Option, Span, Structure, TestCase
+from coom.parser import token_span
+
+
+class Abort(Exception):
+    """Stops compiling the current statement, whose error is already reported or is a syntax error."""
+
+
+@dataclass(eq=False)
+class Compilation:
+    """The model under construction and the diagnostics collected so far."""
+
+    source: str | None = None
+    """The source of the parse tree the current phase works on."""
+    root: Structure = field(default_factory=lambda: Structure(name=ROOT_NAME))
+    structures: list[Structure] = field(default_factory=list)
+    enumerations: list[Enumeration] = field(default_factory=list)
+    behaviors: list[Behavior] = field(default_factory=list)
+    tests: list[TestCase] = field(default_factory=list)
+    diagnostics: list[Diagnostic] = field(default_factory=list)
+    types: dict[str, Structure | Enumeration] = field(default_factory=dict)
+    declared: dict[Any, Structure | Enumeration] = field(default_factory=dict)
+    """The type declared by each product, structure and enumeration block, keyed by its parse tree node."""
+    options: dict[Any, Option] = field(default_factory=dict)
+    """The option declared by each option node, which the attribute values phase completes."""
+    product: Any = None
+    """The first product block, any further one is an error."""
+
+    def span(self, node: Any) -> Span:
+        if isinstance(node, ParserRuleContext):
+            stop = node.stop
+            if stop is None or stop.tokenIndex < node.start.tokenIndex:
+                stop = node.start
+            return token_span(node.start, stop, self.source)
+        return token_span(node, source=self.source)
+
+    def error(self, node: Any, message: str) -> None:
+        self.diagnostics.append(Diagnostic(Severity.ERROR, message, self.span(node)))
+
+    def fail(self, node: Any, message: str) -> NoReturn:
+        self.error(node, message)
+        raise Abort
+
+
+def need[T](node: T | None) -> T:
+    """Returns a parse tree node that error recovery may have left out, aborting the statement if it is missing."""
+    if node is None or isinstance(node, ErrorNode):
+        raise Abort
+    return node
+
+
+def children(node: Any) -> list[Any]:
+    return list(node.children or ()) if node is not None else []
+
+
+_ESCAPE = re.compile(r"\\(u[0-9a-fA-F]{4}|.)")
+_ESCAPES = {'"': '"', "\\": "\\", "/": "/", "b": "\b", "f": "\f", "n": "\n", "r": "\r", "t": "\t"}
+
+
+def unquote(text: str) -> str:
+    """Returns the text of a quoted name with its escape sequences resolved, other names unchanged."""
+    if len(text) < 2 or text[0] not in "'\"" or text[-1] != text[0]:
+        return text
+
+    def resolve(match: re.Match[str]) -> str:
+        escape = match.group(1)
+        return chr(int(escape[1:], 16)) if escape[0] == "u" and len(escape) == 5 else _ESCAPES.get(escape, escape)
+
+    return _ESCAPE.sub(resolve, text[1:-1])
+
+
+def name(node: Any) -> str:
+    return unquote(need(node).getText())