quantum-framework 0.16.0__tar.gz → 0.18.0__tar.gz

{quantum_framework-0.16.0/quantum_framework.egg-info → quantum_framework-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-framework
-Version: 0.16.0
+Version: 0.18.0
 Summary: Full-stack declarative framework for building web, desktop, and mobile applications
 Author-email: Daniel Gregorio <danielgregorio2611@gmail.com>
 License: MIT

{quantum_framework-0.16.0 → quantum_framework-0.18.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantum-framework"
-version = "0.16.0"
+version = "0.18.0"
 description = "Full-stack declarative framework for building web, desktop, and mobile applications"
 readme = "README.md"
 license = {text = "MIT"}

quantum_framework-0.18.0/quantum/cli/check.py

@@ -0,0 +1,223 @@
+"""`quantum check`: every page parses, every q:query compiles against the database,
+and every `{query.field}` a page reads is a column the query returns (M8, DEV-3).
+
+A typo in SQL or in a field name used to surface only when someone opened the
+page — `no such column` as a 500, or, for a field, an empty cell. This reads
+the project the way the server would and reports each problem with its file
+and line, without running anything: a query is compiled by the database
+(EXPLAIN) and a SELECT's columns come from running it with LIMIT 0.
+"""
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterator, List, Optional
+
+# Fields of `<name>_result` and of a query row that are not columns.
+_META = {'recordCount', 'columnList', 'executionTime', 'success', 'error', 'sql', 'page',
+         'totalPages', 'hasMore', 'cached', 'affectedRows', 'lastInsertId', 'data', 'length'}
+_EXPR = re.compile(r'\{([^{}]*)\}')
+
+
+@dataclass
+class Problem:
+    file: str
+    line: Optional[int]
+    message: str
+
+    def __str__(self) -> str:
+        return f'{self.file}:{self.line or "?"}: {self.message}'
+
+
+def _config(config_path: Path) -> dict:
+    import yaml
+    from quantum.core.config_env import expand_env
+    if not config_path.exists():
+        return {}
+    return expand_env(yaml.safe_load(config_path.read_text(encoding='utf-8')) or {})
+
+
+def _children(node) -> Iterator:
+    """The nodes inside a node, whatever the field is called."""
+    for campo in ('statements', 'body', 'if_body', 'else_body', 'children'):
+        for filho in getattr(node, campo, None) or []:
+            if hasattr(filho, '__dict__'):
+                yield filho
+    for bloco in getattr(node, 'elseif_blocks', None) or []:
+        corpo = bloco.get('body') if isinstance(bloco, dict) else getattr(bloco, 'body', None)
+        for filho in corpo or []:
+            yield filho
+
+
+def _texts(node) -> List[str]:
+    """The strings of a node that may hold {expressions}."""
+    textos = []
+    for campo, valor in vars(node).items():
+        if campo.startswith('_') or campo in ('sql',):
+            continue
+        if isinstance(valor, str) and '{' in valor:
+            textos.append(valor)
+        elif isinstance(valor, dict):
+            textos += [v for v in valor.values() if isinstance(v, str) and '{' in v]
+    return textos
+
+
+class ProjectChecker:
+    def __init__(self, project: Path, config_path: Path):
+        self.project = project
+        self.config = _config(config_path)
+        self.datasources = self.config.get('datasources') or {}
+        self._conexoes: Dict[str, object] = {}
+        self.problems: List[Problem] = []
+        self.notes: List[str] = []
+        self.queries_checked = 0
+        self.files = 0
+
+    # -- the database ---------------------------------------------------------
+
+    def _connection(self, nome: str):
+        from quantum.runtime.db_schema import SchemaError, connect_readonly
+        if nome not in self._conexoes:
+            try:
+                self._conexoes[nome] = connect_readonly(self.datasources[nome], self.project)
+            except SchemaError as exc:
+                self._conexoes[nome] = None
+                self.notes.append(f'datasource {nome!r} not checked: {exc}')
+        return self._conexoes[nome]
+
+    # -- a file ---------------------------------------------------------------
+
+    def check_file(self, arquivo: Path) -> None:
+        from quantum.core.parser import QuantumParser
+        rel = arquivo.relative_to(self.project).as_posix() if arquivo.is_relative_to(self.project) else str(arquivo)
+        self.files += 1
+        try:
+            ast = QuantumParser(use_cache=False).parse_file(str(arquivo))
+        except Exception as exc:        # a parse error is a problem like any other
+            primeira = str(exc).split('\n')[0]
+            self.problems.append(Problem(rel, getattr(exc, 'line', None), primeira))
+            return
+        colunas: Dict[str, List[str]] = {}
+        self._queries(ast, rel, colunas)
+        self._fields(ast, rel, colunas, {nome: nome for nome in colunas}, None)
+
+    def _queries(self, node, rel: str, colunas: Dict[str, List[str]]) -> None:
+        from quantum.core.ast_nodes import ActionNode, QueryNode
+        from quantum.runtime.db_schema import check_sql, read_schema
+        for filho in _children(node):
+            if isinstance(filho, ActionNode) and getattr(filho, 'table', None):
+                # UI-10: the table the action takes its params from exists, with those columns.
+                ds = filho.table_datasource
+                if ds not in self.datasources:
+                    self.problems.append(Problem(rel, getattr(filho, 'source_line', None),
+                                                 f'<q:action name="{filho.name}">: datasource {ds!r} is not '
+                                                 f'declared in quantum.config.yaml'))
+                elif self._connection(ds) is not None:
+                    esquema = read_schema(self._connection(ds))
+                    tabela = esquema.get(filho.table)
+                    if tabela is None:
+                        self.problems.append(Problem(rel, getattr(filho, 'source_line', None),
+                                                     f'<q:action name="{filho.name}" table="{filho.table}">: '
+                                                     f'no such table (tables: {", ".join(esquema) or "none"})'))
+                    else:
+                        for coluna in filho.table_columns or []:
+                            if coluna not in tabela.columns:
+                                self.problems.append(Problem(
+                                    rel, getattr(filho, 'source_line', None),
+                                    f'<q:action name="{filho.name}" columns=...>: table "{filho.table}" '
+                                    f'has no column "{coluna}"'))
+            if isinstance(filho, QueryNode):
+                ds = filho.datasource
+                if not ds or ds.startswith('knowledge:') or getattr(filho, 'source', None):
+                    pass                                 # RAG or query of queries: not SQL on a database
+                elif ds not in self.datasources:
+                    self.problems.append(Problem(rel, getattr(filho, 'source_line', None),
+                                                 f'<q:query name="{filho.name}">: datasource {ds!r} is not '
+                                                 f'declared in quantum.config.yaml'))
+                else:
+                    conexao = self._connection(ds)
+                    if conexao is not None:
+                        self.queries_checked += 1
+                        erro, cols = check_sql(conexao, filho.sql or '')
+                        if erro:
+                            self.problems.append(Problem(rel, getattr(filho, 'source_line', None),
+                                                         f'<q:query name="{filho.name}">: {erro}'))
+                        elif cols is not None:
+                            colunas[filho.name] = cols
+            self._queries(filho, rel, colunas)
+
+    def _fields(self, node, rel: str, colunas: Dict[str, List[str]], ligados: Dict[str, str],
+                linha: Optional[int]) -> None:
+        """Each `{var.field}` where var is a query, or a row of one, names a column it returns."""
+        from quantum.core.features.loops.src.ast_node import LoopNode
+        from quantum.core.features.ui_engine.src.ast_nodes import UIColumnNode, UIListNode, UITableNode
+        linha = getattr(node, 'source_line', None) or linha
+        for texto in _texts(node):
+            for expressao in _EXPR.findall(texto):
+                for var, campo in re.findall(r'(?<![\w.])(\w+)\.(\w+)', expressao):
+                    self._field(rel, linha, colunas, ligados, var, campo)
+        if isinstance(node, UIColumnNode) and node.key and '$tabela' in ligados:
+            self._field(rel, linha, colunas, ligados, '$tabela', node.key, f'<ui:column key="{node.key}">')
+
+        for filho in _children(node):
+            dentro = dict(ligados)
+            origem = None
+            if isinstance(filho, LoopNode):
+                origem = filho.query_name if filho.loop_type == 'query' else _single_name(filho.items)
+                if origem in colunas:
+                    dentro[filho.var_name] = origem
+            elif isinstance(filho, (UITableNode, UIListNode)):
+                origem = _single_name(filho.source)
+                if origem in colunas:
+                    dentro[filho.as_var or ('row' if isinstance(filho, UITableNode) else 'item')] = origem
+                    if isinstance(filho, UITableNode):
+                        dentro['$tabela'] = origem
+            self._fields(filho, rel, colunas, dentro, linha)
+
+    def _field(self, rel, linha, colunas, ligados, var, campo, como=None) -> None:
+        consulta = ligados.get(var)
+        if consulta is None or campo in _META:
+            return
+        cols = colunas.get(consulta, [])
+        if campo not in cols:
+            quem = como or f'{{{var}.{campo}}}'
+            self.problems.append(Problem(
+                rel, linha, f'{quem}: query "{consulta}" returns no column "{campo}" '
+                            f'(columns: {", ".join(cols) or "none"})'))
+
+    # -- the project ----------------------------------------------------------
+
+    def run(self) -> List[Problem]:
+        pasta = self.project / (self.config.get('paths', {}) or {}).get('components', 'components')
+        if not pasta.exists():
+            self.notes.append(f'no components folder at {pasta}')
+            return self.problems
+        for arquivo in sorted(pasta.rglob('*.q')):
+            self.check_file(arquivo)
+        for conexao in self._conexoes.values():
+            if conexao is not None:
+                conexao.close()
+        return self.problems
+
+
+def _single_name(expr: Optional[str]) -> Optional[str]:
+    """`{tarefas}` -> 'tarefas'; anything more complex -> None."""
+    m = re.fullmatch(r'\s*\{\s*(\w+)\s*\}\s*', expr or '')
+    return m.group(1) if m else None
+
+
+def run_check(config_path: str = 'quantum.config.yaml') -> int:
+    """`quantum check`: print each problem as file:line: message; exit 1 if there is any."""
+    caminho = Path(config_path).resolve()
+    checker = ProjectChecker(caminho.parent, caminho)
+    problemas = checker.run()
+    for nota in checker.notes:
+        print(f'[NOTE] {nota}')
+    for problema in problemas:
+        print(problema)
+    resumo = (f'{checker.files} file(s), {checker.queries_checked} query(ies) checked against the database')
+    if problemas:
+        print(f'\n{len(problemas)} problem(s) — {resumo}.')
+        return 1
+    print(f'OK — {resumo}.')
+    return 0

{quantum_framework-0.16.0 → quantum_framework-0.18.0}/quantum/cli/runner.py

@@ -287,6 +287,7 @@ Examples:
   quantum admin                    # Start the Quantum Admin
   quantum console                  # The application's pages in the terminal
   quantum desktop                  # The application's pages in a desktop window
+  quantum check                    # Pages parse, SQL compiles, query fields exist
   quantum run game.q --engine godot # Build Godot 4 project
   quantum run backup-job.q         # Execute job
   quantum deploy ./my-app          # Deploy application
@@ -342,6 +343,10 @@ Examples:
     console_parser.add_argument('path', nargs='?', default='/', help='Page to open (default: /)')
     console_parser.add_argument('--config', default='quantum.config.yaml', help='Config file')
 
+    # Check: pages parse, queries compile, fields exist (M8, DEV-3)
+    check_parser = subparsers.add_parser('check', help='Check pages, SQL and query fields against the database')
+    check_parser.add_argument('--config', default='quantum.config.yaml', help='Config file')
+
     # Desktop: the application's pages in a native window (UI-4)
     desktop_parser = subparsers.add_parser('desktop', help="Open the application's pages in a desktop window")
     desktop_parser.add_argument('path', nargs='?', default='/', help='Page to open (default: /)')
@@ -419,6 +424,10 @@ Examples:
         from quantum.runtime.ui_console import run_console
         sys.exit(run_console(args.config, args.path))
 
+    elif args.command == 'check':
+        from quantum.cli.check import run_check
+        sys.exit(run_check(args.config))
+
     elif args.command == 'desktop':
         from quantum.runtime.ui_desktop import run_desktop
         sys.exit(run_desktop(args.config, args.path, width=args.width, height=args.height))

{quantum_framework-0.16.0 → quantum_framework-0.18.0}/quantum/core/ast_nodes.py

@@ -698,6 +698,8 @@ class QueryNode(QuantumNode):
         self.interval = None
         self.paginate = False  # Enable automatic pagination
         self.page = None
+        self.page_expr = None  # DB-9: page as an expression (default {query.page})
+        self.sortable = False  # UI-13: ORDER BY the URL's ?sort=/&dir=
         self.page_size = 20
         self.timeout = None
         self.maxrows = None
@@ -1137,6 +1139,10 @@ class ActionNode(QuantumNode):
         self.method = method.upper()
         self.params: List[QuantumParam] = []
         self.body: List[QuantumNode] = []
+        # UI-10 (M17): params from a table's schema — see quantum/runtime/table_params.py
+        self.table: Optional[str] = None
+        self.table_datasource: Optional[str] = None
+        self.table_columns: Optional[List[str]] = None
 
         # Action configuration
         self.validate_csrf = True  # Auto CSRF protection

{quantum_framework-0.16.0 → quantum_framework-0.18.0}/quantum/core/features/ui_engine/src/ast_nodes.py

@@ -319,6 +319,9 @@ class UIFormNode(QuantumNode, UILayoutMixin):
 
     def __init__(self):
         self.on_submit: Optional[str] = None
+        self.rules: Optional[str] = None  # UI-9: 'off' = no rules from the action
+        self.values: Optional[str] = None  # UI-10: {row} whose fields fill the form
+        self.submit: Optional[str] = None  # UI-10: text of the generated button
         self.children: List[QuantumNode] = []
 
         # Validation mode: 'client', 'server', or 'both' (default)
@@ -550,6 +553,8 @@ class UIInputNode(QuantumNode, UILayoutMixin):
     def __init__(self):
         self.bind: Optional[str] = None
         self.value: Optional[str] = None  # initial value (UI-6)
+        self.search: Optional[str] = None  # UI-12: id of the region it refreshes as you type
+        self.delay: Optional[int] = None   # UI-12: ms after the last key (300 with search=)
         self.placeholder: Optional[str] = None
         self.input_type: str = "text"    # text, password, email, number
         self.on_change: Optional[str] = None
@@ -673,6 +678,9 @@ class UITableNode(QuantumNode, UILayoutMixin):
     def __init__(self):
         self.source: Optional[str] = None
         self.as_var: Optional[str] = None  # row variable for column content (UI-5)
+        self.sort: bool = False               # UI-13: headers sort the query
+        self.edit: Optional[str] = None       # UI-13: table whose cells are edited in place
+        self.edit_datasource: Optional[str] = None
         self.children: List[QuantumNode] = []  # UIColumnNode children
         self._init_layout_attrs()
 
@@ -697,6 +705,7 @@ class UIColumnNode(QuantumNode):
         self.label: Optional[str] = None
         self.column_width: Optional[str] = None
         self.align: Optional[str] = None  # left, center, right
+        self.edit: bool = True            # UI-13: edit="false" keeps it read-only
         # UI-5: a column with content draws it once per row (buttons, links).
         self.children: List[QuantumNode] = []
 
@@ -1870,6 +1879,23 @@ class UIDatePickerNode(QuantumNode, UILayoutMixin):
         return self._validate_layout()
 
 
+class UIPagerNode(QuantumNode, UILayoutMixin):
+    """<ui:pager for="query"> — previous, page numbers and next over a paginated query (UI-11)."""
+
+    def __init__(self):
+        self.for_query: Optional[str] = None
+        self.param: str = 'page'
+        self.window: int = 2
+        self.children: List[QuantumNode] = []
+        self._init_layout_attrs()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"type": "ui_pager", "for": self.for_query, "param": self.param}
+
+    def validate(self) -> List[str]:
+        return [] if self.for_query else ["ui:pager needs for="]
+
+
 def is_ui_node(node) -> bool:
     """A ui:* element (UI-1): markup, drawn by a renderer, never executed."""
     return type(node).__module__ == __name__
@@ -1882,6 +1908,6 @@ CORE_TAGS = frozenset({
     'window', 'hbox', 'vbox', 'grid', 'panel', 'section', 'scrollbox', 'spacer', 'rule',
     'header', 'footer', 'card', 'card-header', 'card-body', 'card-footer', 'tabpanel', 'tab',
     'text', 'badge', 'alert', 'link', 'image', 'progress',
-    'table', 'column', 'list', 'item',
+    'table', 'column', 'list', 'item', 'pager',
     'form', 'formitem', 'input', 'checkbox', 'switch', 'radio', 'select', 'option', 'button',
 })

{quantum_framework-0.16.0 → quantum_framework-0.18.0}/quantum/core/features/ui_engine/src/parser.py

@@ -28,7 +28,7 @@ from .ast_nodes import (
     UIToastNode, UIToastContainerNode,
     UICarouselNode, UISlideNode,
     UIStepperNode, UIStepNode,
-    UICalendarNode, UIDatePickerNode,
+    UICalendarNode, UIDatePickerNode, UIPagerNode,
 )
 from quantum.core.features.theming.src import UIThemeNode, UIColorNode
 from quantum.core.ast_nodes import TextNode
@@ -81,6 +81,7 @@ class UIParser:
         'select': '_parse_ui_select',
         'table': '_parse_ui_table',
         'column': '_parse_ui_column',
+        'pager': '_parse_ui_pager',
         'list': '_parse_ui_list',
         'item': '_parse_ui_item',
         'image': '_parse_ui_image',
@@ -137,9 +138,24 @@ class UIParser:
             import difflib
             parecidas = difflib.get_close_matches(local_name, self.UI_TAG_MAP, n=1)
             dica = f"; did you mean <ui:{parecidas[0]}>?" if parecidas else ""
-            raise UIParseError(f"Unknown UI tag: <ui:{local_name}>{dica}")
+            erro = UIParseError(f"Unknown UI tag: <ui:{local_name}>{dica}")
+            erro.line = getattr(element, 'sourceline', None)
+            raise erro
         method = getattr(self, method_name)
-        return method(element)
+        try:
+            node = method(element)
+        except UIParseError as exc:
+            if getattr(exc, 'line', None) is None:
+                exc.line = getattr(element, 'sourceline', None)
+            raise
+        # DEV-2: a ui:* element knows its line and file, like a q: statement.
+        if getattr(element, 'sourceline', None) and node is not None:
+            try:
+                node.source_line = element.sourceline
+                node.source_file = getattr(self.parent, '_source_path', None)
+            except AttributeError:
+                pass
+        return node
 
     # ------------------------------------------------------------------
     # Helpers
@@ -344,6 +360,13 @@ class UIParser:
         node = UIFormNode()
         node.on_submit = element.get('on-submit')
         node.send = element.get('with')
+        # UI-9: rules="off" stops the form from taking its fields' rules from the action.
+        node.rules = element.get('rules')
+        # UI-10: an edit form opens with a row's values; the generated button's text.
+        node.values = element.get('values')
+        node.submit = element.get('submit')
+        if node.rules not in (None, 'on', 'off'):
+            raise UIParseError(f'<ui:form rules="{node.rules}">: use on (the default) or off')
 
         # Validation attributes
         node.validation_mode = element.get('validation', 'both')
@@ -415,6 +438,14 @@ class UIParser:
         node = UIInputNode()
         node.bind = element.get('bind')
         node.value = element.get('value')
+        # UI-12: search as you type — refresh the element with this id.
+        node.search = element.get('search')
+        espera = element.get('delay')
+        if espera is not None and not espera.isdigit():
+            raise UIParseError(f'<ui:input delay="{espera}">: milliseconds, e.g. delay="300"')
+        node.delay = int(espera) if espera is not None else (300 if node.search else None)
+        if node.search is not None and not node.bind:
+            raise UIParseError('<ui:input search=...> needs bind= (the URL parameter it sets)')
         node.placeholder = element.get('placeholder')
         node.input_type = element.get('type', 'text')
         node.on_change = element.get('on-change')
@@ -483,6 +514,14 @@ class UIParser:
         node = UITableNode()
         node.source = element.get('source')
         node.as_var = element.get('as')
+        # UI-13: sortable headers and cells edited in place.
+        node.sort = self._parse_bool(element.get('sort'))
+        node.edit = element.get('edit')
+        node.edit_datasource = element.get('datasource')
+        if node.edit and not node.edit_datasource:
+            raise UIParseError(f'<ui:table edit="{node.edit}"> needs datasource= (where the table is)')
+        if (node.sort or node.edit) and not node.source:
+            raise UIParseError('<ui:table sort/edit> needs source="{query}"')
         self._apply_layout_attrs(node, element)
         # Parse child <ui:column> elements
         self._parse_children(element, node)
@@ -494,9 +533,23 @@ class UIParser:
         node.label = element.get('label')
         node.column_width = element.get('width')
         node.align = element.get('align')
+        node.edit = element.get('edit', 'true') != 'false'
         self._parse_children(element, node)
         return node
 
+    def _parse_ui_pager(self, element: ET.Element) -> UIPagerNode:
+        node = UIPagerNode()
+        node.for_query = element.get('for')
+        if not node.for_query:
+            raise UIParseError('<ui:pager> needs for="<the paginated q:query>"')
+        node.param = element.get('param') or 'page'
+        janela = element.get('window')
+        if janela is not None and not janela.isdigit():
+            raise UIParseError(f'<ui:pager window="{janela}">: the number of pages shown each side of the current one')
+        node.window = int(janela) if janela is not None else 2
+        self._apply_layout_attrs(node, element)
+        return node
+
     def _parse_ui_list(self, element: ET.Element) -> UIListNode:
         node = UIListNode()
         node.source = element.get('source')

{quantum_framework-0.16.0 → quantum_framework-0.18.0}/quantum/core/parser.py

@@ -11,6 +11,7 @@ from typing import Union, Optional, List
 # Fix imports
 
 from quantum.core.html_compat import normalise_html
+from quantum.core.xml_lines import fromstring_with_lines, line_of
 from quantum.core.ast_nodes import (
     QuantumNode, ComponentNode, ApplicationNode, JobNode,
     QuantumParam, QuantumReturn, QuantumRoute,
@@ -222,6 +223,23 @@ def _explain_xml_error(error, source: str) -> str:
     return message
 
 
+def _at(erro: 'QuantumParseError', onde) -> 'QuantumParseError':
+    """The error belongs to this node's (or element's) line."""
+    erro.line = line_of(onde)
+    return erro
+
+
+def _with_line(erro: 'QuantumParseError', source: str, line: Optional[int] = None) -> 'QuantumParseError':
+    """DEV-2: a parse error says where it is — `at line N: <the line>`."""
+    line = line or getattr(erro, 'line', None)
+    erro.line = line
+    if line and ' at line ' not in str(erro):
+        linhas = source.splitlines()
+        trecho = linhas[line - 1].strip() if 0 < line <= len(linhas) else ''
+        erro.args = (f"{erro}\n  at line {line}: {trecho}" if trecho else f"{erro} (line {line})",)
+    return erro
+
+
 class QuantumParser:
     """Main parser for .q files"""
 
@@ -370,17 +388,19 @@ class QuantumParser:
             # parse for exactly those two reasons and returned HTTP 400.
             content = normalise_html(source)
             content = self._inject_namespace(content)
-            root = ET.fromstring(content)
+            root = fromstring_with_lines(content)
             self._nest_else_siblings(root)
             return self._parse_root_element(root, Path("<string>"))
         except ET.ParseError as e:
-            raise QuantumParseError(_explain_xml_error(e, source))
-        except QuantumParseError:
-            raise
+            erro = QuantumParseError(_explain_xml_error(e, source))
+            erro.line = getattr(e, 'position', (None, None))[0]
+            raise erro
+        except QuantumParseError as e:
+            raise _with_line(e, source)
         except ParserError as e:
             # A tag parser's own error is a parse error with a message meant
             # for the author, not an "Unexpected error".
-            raise QuantumParseError(str(e)) from e
+            raise _with_line(QuantumParseError(str(e)), source, getattr(e, 'line', None)) from e
         except Exception as e:
             raise QuantumParseError(f"Unexpected error: {e}")
 
@@ -412,7 +432,9 @@ class QuantumParser:
             self._source_path = str(path.resolve())
             source = Path(file_path).read_text(encoding="utf-8")
             return self.parse(source)
-        except QuantumParseError:
+        except QuantumParseError as e:
+            if getattr(e, 'file', None) is None:
+                e.file = str(path.resolve())                  # DEV-2
             raise
         except ParserError as e:
             # A tag parser's own error is a parse error with a message meant
@@ -498,7 +520,7 @@ class QuantumParser:
         conhecidas |= {'return', 'else', 'elseif'}
         parecidas = difflib.get_close_matches(name, sorted(conhecidas), n=3, cutoff=0.6)
         dica = (" Did you mean " + " or ".join(f"<q:{p}>" for p in parecidas) + "?") if parecidas else ""
-        return f"<q:{name}> is not a Quantum tag.{dica}"
+        return f"<q:{name}> is not a Quantum tag (PARSE-1).{dica}"
 
     @staticmethod
     def _is_quantum_tag(element: ET.Element) -> bool:
@@ -683,12 +705,12 @@ class QuantumParser:
                 lidos = names_read(re.sub(r'\{([^{}]*)\}', r'\1', condicao)) & definidos
                 if lidos:
                     nome = sorted(lidos)[0]
-                    raise QuantumParseError(
+                    raise _at(QuantumParseError(
                         f'<q:if condition="{condicao}"> in <q:component name="{component.name}"> '
-                        f'redirects, so it also runs before the page\'s q:action — where the page '
+                        f'redirects (AUTH-6), so it also runs before the page\'s q:action — where the page '
                         f'has not run and {{{nome}}} does not exist, and the guard would let the '
                         f'action through. Read the scope directly (e.g. session.x), or protect the '
-                        f'page with require_auth / require_role. See {HOW_A_PAGE_RUNS}')
+                        f'page with require_auth / require_role. See {HOW_A_PAGE_RUNS}'), guarda)
 
     # Nodes the HTML renderer draws. Anything else inside markup is a statement,
     # and statements run in the execution pass, before the render pass sees
@@ -762,21 +784,21 @@ class QuantumParser:
             for node in nodes:
                 if not isinstance(node, self._RENDERED) and not is_ui_node(node):
                     if onde and onde[0] == 'markup':
-                        raise QuantumParseError(
+                        raise _at(QuantumParseError(
                             f'{tag(node)} inside {onde[1]} in <q:component name="{component.name}"> '
-                            f'never runs: statements run before the page is rendered, and markup '
+                            f'never runs (PARSE-2): statements run before the page is rendered, and markup '
                             f'is only rendered. Move it above the markup (or into a q:action). '
-                            f'See {HOW_A_PAGE_RUNS}')
+                            f'See {HOW_A_PAGE_RUNS}'), node)
                     nome = getattr(node, 'name', None)
                     # A running total read AFTER the loop is fine; a value the
                     # loop's own rows read is not.
                     if onde and isinstance(nome, str) and usado(nome, onde[1]):
-                        raise QuantumParseError(
+                        raise _at(QuantumParseError(
                             f'{tag(node)} inside a q:loop whose rows use {{{nome}}} in '
                             f'<q:component name="{component.name}">: the loop runs for every item '
-                            f'before any row is rendered, so every row would show the last value. '
+                            f'before any row is rendered, so every row would show the last value (PARSE-2). '
                             f'Compute it in the expression instead, e.g. {{item.price * item.qty}}. '
-                            f'See {HOW_A_PAGE_RUNS}')
+                            f'See {HOW_A_PAGE_RUNS}'), node)
                     continue
                 if isinstance(node, HTMLNode):
                     andar(filhos(node), onde if onde and onde[0] == 'markup' else ('markup', f'<{node.tag}>'))
@@ -844,6 +866,27 @@ class QuantumParser:
                 if_node.add_else_statement(stmt)
 
     def _parse_statement(self, element: ET.Element) -> Optional[QuantumNode]:
+        """Parse one statement, and remember where it is in the file (DEV-2).
+
+        The node gets `source_line`, which runtime errors report; a parse
+        error from this element — or from inside it, if nothing deeper
+        claimed it — gets `line`.
+        """
+        try:
+            node = self._parse_statement_node(element)
+        except (QuantumParseError, ParserError) as exc:
+            if getattr(exc, 'line', None) is None:
+                exc.line = getattr(element, 'sourceline', None)
+            raise
+        if node is not None and getattr(element, 'sourceline', None):
+            try:
+                node.source_line = element.sourceline
+                node.source_file = self._source_path
+            except AttributeError:
+                pass                                  # a node with __slots__
+        return node
+
+    def _parse_statement_node(self, element: ET.Element) -> Optional[QuantumNode]:
         """Parse individual statement (return, set, dispatchEvent, etc)"""
         element_type = self._get_element_name(element)
 
@@ -857,7 +900,9 @@ class QuantumParser:
                 try:
                     return UIParser(self, page_mode=True).parse_ui_element(element_type, element)
                 except UIParseError as exc:
-                    raise QuantumParseError(str(exc)) from exc
+                    erro = QuantumParseError(str(exc))
+                    erro.line = getattr(exc, 'line', None)          # the inner ui:* element's line
+                    raise erro from exc
 
             # PARSE-1: <q:html>, <q:div> — an HTML element name in the q:
             # namespace. The registry answered for it with the HTML parser, so

{quantum_framework-0.16.0 → quantum_framework-0.18.0}/quantum/core/parsers/data/query_parser.py

@@ -77,7 +77,27 @@ class QueryParser(BaseTagParser):
         # Parse attributes
         query_node.source = source
         query_node.paginate = self.get_bool_attr(element, 'paginate', False)
-        query_node.page = self.get_int_attr(element, 'page', 0) or None
+        # UI-13: ordered by the URL's ?sort=/&dir= (a <ui:table sort="true"> writes them)
+        query_node.sortable = self.get_bool_attr(element, 'sortable', False)
+        # DB-9: page= is an expression, resolved when the query runs; it was
+        # read as an int at parse time, so page="{query.page}" was always
+        # page 1. With paginate="true" and no page=, the page is the URL's
+        # `page` parameter — the one <ui:pager> writes.
+        pagina = element.get('page')
+        query_node.page = None
+        query_node.page_expr = None
+        if pagina is not None:
+            if '{' in pagina:
+                query_node.page_expr = pagina
+            elif pagina.strip().isdigit():
+                query_node.page = int(pagina)
+            else:
+                from quantum.core.parser import QuantumParseError
+                raise QuantumParseError(
+                    f'<q:query name="{name}" page="{pagina}">: a page number or an expression, '
+                    f'e.g. page="{{query.pagina}}"')
+        elif query_node.paginate:
+            query_node.page_expr = '{query.page}'
         # Accept both spellings: the codebase convention is camelCase, but
         # snake_case reads naturally in XML and the examples used it —
         # the mismatch made page_size None and crashed pagination with