ssc_codegen 0.25.2__tar.gz → 0.26.1__tar.gz

{ssc_codegen-0.25.2 → ssc_codegen-0.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssc_codegen
-Version: 0.25.2
+Version: 0.26.1
 Summary: Python-dsl code converter to html parser for web scraping 
 Project-URL: Documentation, https://github.com/vypivshiy/selector_schema_codegen#readme
 Project-URL: Issues, https://github.com/vypivshiy/selector_schema_codegen/issues

{ssc_codegen-0.25.2 → ssc_codegen-0.26.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ssc_codegen"
-version = "0.25.2"
+version = "0.26.1"
 description = "Python-dsl code converter to html parser for web scraping "
 readme = "README.md"
 requires-python = ">=3.10"

{ssc_codegen-0.25.2 → ssc_codegen-0.26.1}/ssc_codegen/converters/request_spec.py

@@ -20,7 +20,7 @@ from ssc_codegen.parsers.http import parse_http_request
 # Groups: 1=NAME, 2=PRIM, 3="[]", 4="?", 5=STYLE.
 _PH = re.compile(
     r"\{\{"
-    r"([A-Za-z][A-Za-z0-9_-]*)"
+    r"([a-z][a-z0-9_-]*)"
     r"(?::(str|int|float|bool))?"
     r"(\[\])?"
     r"(\?)?"

{ssc_codegen-0.25.2 → ssc_codegen-0.26.1}/ssc_codegen/core/expressions.py

@@ -167,7 +167,7 @@ _FLOAT_RE = _re.compile(
     r"[+-]?(?:\d(?:[\d_])*\.\d(?:[\d_])*|\d(?:[\d_])*[eE][+-]?\d(?:[\d_])*|\d(?:[\d_]*)\.\d(?:[\d_]*)[eE][+-]?\d(?:[\d_])*)\Z"
 )
 
-_DEFINE_REF_RE = _re.compile(r"\{\{([A-Za-z][A-Za-z0-9_-]*)\}\}")
+_DEFINE_REF_RE = _re.compile(r"\{\{([A-Z_][A-Z0-9_-]*)\}\}")
 
 
 def _resolve_define_references(value: str, ctx: ParseContext) -> str:
@@ -175,7 +175,7 @@ def _resolve_define_references(value: str, ctx: ParseContext) -> str:
         name = m.group(1)
         resolved = ctx.property_defines.get(name)
         if resolved is None:
-            raise ParseError(f"define references undefined name {name!r}")
+            return m.group(0)
         return str(resolved)
 
     return _DEFINE_REF_RE.sub(_replacer, value)
@@ -438,6 +438,9 @@ def parse_expressions(
         lint.push(node.name)
         lint_pipeline_op(node, lint)
         expr = handler(node, parent, ctx, lint)  # type: ignore[assignment,arg-type]
+        if expr is None:
+            lint.pop()
+            continue
         if isinstance(expr, Fallback):
             lint.pop()
             continue
@@ -920,7 +923,12 @@ def _expr_jsonify(
     )
     json_def = ctx.json_defs.get(schema_name)
     if json_def is None:
-        raise ParseError(f"jsonify: JSON schema '{schema_name}' not found")
+        lint.error(
+            node,
+            message=f"jsonify: JSON schema '{schema_name}' not found",
+            code="E300",
+        )
+        return None
     ret_type, is_array = resolve_jsonify_type(json_def, path, ctx)
     return Jsonify(
         parent=parent,
@@ -938,7 +946,12 @@ def _expr_nested(
     struct_name = str(node.args[0].value)
     struct = ctx.structs.get(struct_name)
     if struct is None:
-        raise ParseError(f"nested: struct '{struct_name}' not found")
+        lint.error(
+            node,
+            message=f"nested: struct '{struct_name}' not found",
+            code="E300",
+        )
+        return None
     is_array = struct.struct_type in (StructType.FLAT, StructType.LIST)
     return Nested(parent=parent, struct_name=struct_name, is_array=is_array)
 

{ssc_codegen-0.25.2 → ssc_codegen-0.26.1}/ssc_codegen/core/linting.py

@@ -1111,12 +1111,24 @@ def lint_rest_cross_refs(ctx: ParseContext, lint: LintContext) -> None:
             )
 
 
+_DEFINE_NAME_RE = _re.compile(r"^[A-Z_][A-Z0-9_-]*\Z")
+
+
 def lint_define_node(
     node: KdlNode, ctx: ParseContext, lint: LintContext
 ) -> None:
     """Validate module-level define."""
     children = lint.get_children_nodes(node)
     args = lint.get_args(node)
+    if args:
+        name = args[0]
+        if not _DEFINE_NAME_RE.match(name):
+            lint.error(
+                node,
+                message=f"define name '{name}' must be UPPER_CASE ([A-Z_][A-Z0-9_-]*)",
+                code="E002",
+                hint="use UPPER_CASE: define MY-VAR=... or define MY_BLOCK { ... }",
+            )
     if children:
         if not args:
             lint.error(

{ssc_codegen-0.25.2 → ssc_codegen-0.26.1}/ssc_codegen/core/module_handler.py

@@ -12,7 +12,7 @@ from ssc_codegen.ast import (
     TransformDef,
     TransformTarget,
 )
-from ssc_codegen.exceptions import BuildTimeError, ParseError
+from ssc_codegen.exceptions import BuildTimeError
 from ssc_codegen.kdl import (
     KDL2CSTParser,
     KdlArg,
@@ -142,13 +142,19 @@ def handle_transform(
         ).value
     )
     if accept_str not in _VAR_TYPE_MAP:
-        raise ParseError(
-            f"transform '{name}': invalid accept type '{accept_str}' (AUTO not allowed)"
+        lint.error(
+            node,
+            message=f"transform '{name}': invalid accept type '{accept_str}' (AUTO not allowed)",
+            code="E002",
         )
+        return
     if ret_str not in _VAR_TYPE_MAP:
-        raise ParseError(
-            f"transform '{name}': invalid return type '{ret_str}' (AUTO not allowed)"
+        lint.error(
+            node,
+            message=f"transform '{name}': invalid return type '{ret_str}' (AUTO not allowed)",
+            code="E002",
         )
+        return
     accept_type = _VAR_TYPE_MAP[accept_str]
     ret_type = _VAR_TYPE_MAP[ret_str]
     transform_def = TransformDef(name=name, accept=accept_type, ret=ret_type)

{ssc_codegen-0.25.2 → ssc_codegen-0.26.1}/ssc_codegen/core/reader.py

@@ -6,13 +6,17 @@ from collections.abc import Mapping
 from pathlib import Path
 
 from ssc_codegen.ast import Module
+from ssc_codegen.exceptions import BuildTimeError, ParseError
 from ssc_codegen.kdl import (
     KDL2CSTParser,
+    KDLParseError,
     KdlArg,
     KdlNode,
+    Position,
     ReadDiagnostic,
     Reader,
     Severity,
+    Span,
     WalkContext,
     parse_into,
 )
@@ -128,6 +132,34 @@ def parse_module(
 ) -> tuple[Module, list[ReadDiagnostic]]:
     """Parse KDL source -> Module AST + diagnostics."""
     parser = KDL2CSTParser()
-    doc = parser.parse(src)
+    try:
+        doc = parser.parse(src)
+    except KDLParseError as exc:
+        pos = Position(offset=exc.offset, line=exc.line, column=exc.column)
+        span = Span(start=pos, end=pos)
+        return Module(), [
+            ReadDiagnostic(
+                message=exc.message,
+                severity=Severity.ERROR,
+                span=span,
+                path=str(source_path) if source_path else "",
+                hint="Fix the syntax error and try again.",
+                code="E000",
+                label="syntax error",
+            )
+        ]
     reader = SscReader(source_path=source_path)
-    return parse_into(doc, reader)
+    try:
+        return parse_into(doc, reader)
+    except (ParseError, BuildTimeError) as exc:
+        pos = Position(offset=0, line=0, column=0)
+        span = Span(start=pos, end=pos)
+        return Module(), [
+            ReadDiagnostic(
+                message=str(exc),
+                severity=Severity.ERROR,
+                span=span,
+                path=str(source_path) if source_path else "",
+                code="E000",
+            )
+        ]

{ssc_codegen-0.25.2 → ssc_codegen-0.26.1}/ssc_codegen/core/struct_parser.py

@@ -27,7 +27,6 @@ from ssc_codegen.ast import (
     Value,
     VariableType,
 )
-from ssc_codegen.exceptions import ParseError
 from ssc_codegen.kdl import KdlArg, KdlNode
 
 from ssc_codegen.core.contexts import LintContext, ParseContext, WalkCtx
@@ -56,9 +55,12 @@ def parse_struct(
             parent.body.append(expr)
         elif node.name == "@check":
             if not node.args:
-                raise ParseError(
-                    "@check requires a name: @check <name> { ... }"
+                lint.error(
+                    node,
+                    message="@check requires a name: @check <name> { ... }",
+                    code="E001",
                 )
+                continue
             check_name = str(node.args[0].value)
             expr = CheckMethod(parent=parent, name=check_name)
             parse_expressions(node.children, expr, ctx, lint)
@@ -89,9 +91,12 @@ def parse_struct(
             parent.body.append(expr)
         elif node.name == "@request":
             if not node.args:
-                raise ParseError(
-                    "@request requires a multiline string argument"
+                lint.error(
+                    node,
+                    message="@request requires a multiline string argument",
+                    code="E001",
                 )
+                continue
             raw_payload = str(
                 ctx.property_defines.get(node.args[0].value, node.args[0].value)
             )
@@ -135,14 +140,22 @@ def parse_struct(
             parent.body.append(req)
         elif node.name == "@error":
             if not node.args or len(node.args) < 2:
-                raise ParseError("@error requires both status and schema name")
+                lint.error(
+                    node,
+                    message="@error requires both status and schema name",
+                    code="E001",
+                )
+                continue
             status_raw = node.args[0].value
             try:
                 status_int = int(status_raw)
             except (TypeError, ValueError):
-                raise ParseError(
-                    f"@error status must be integer, got {status_raw!r}"
+                lint.error(
+                    node,
+                    message=f"@error status must be integer, got {status_raw!r}",
+                    code="E002",
                 )
+                continue
             schema_name = str(
                 ctx.property_defines.get(node.args[1].value, node.args[1].value)
             )

{ssc_codegen-0.25.2 → ssc_codegen-0.26.1}/ssc_codegen/main.py

@@ -270,7 +270,9 @@ def generate(
             if skip_lint:
                 pass
             else:
-                lint_output = format_diagnostics(err, fmt=fmt.value)
+                lint_output = format_diagnostics(
+                    err, filepath=kdl_file, fmt=fmt.value
+                )
                 if lint_output:
                     typer.echo(lint_output, err=True)
                     errors.append(lint_output)
@@ -377,9 +379,9 @@ def check(
 
         if errs:
             total_errors += len(errs)
-            # TODO: json output
-            for e in format_diagnostics(errs, fmt=fmt.value):
-                typer.echo(e, err=True)
+            output = format_diagnostics(errs, filepath=kdl_file, fmt=fmt.value)
+            if output:
+                typer.echo(output, err=True)
 
     if total_errors > 0:
         if fmt == FmtType.TEXT:
@@ -495,9 +497,10 @@ def run(
             kdl_path.read_text(encoding="utf-8"), source_path=kdl_path
         )
         if errs:
-            for e in format_diagnostics(errs, fmt=fmt.value):
-                typer.echo(e, err=True)
-                raise typer.Exit(1)
+            output = format_diagnostics(errs, filepath=kdl_path, fmt=fmt.value)
+            if output:
+                typer.echo(output, err=True)
+            raise typer.Exit(1)
 
     except Exception as exc:
         if verbose: