tina4-python 3.13.45__tar.gz → 3.13.47__tar.gz

{tina4_python-3.13.45 → tina4_python-3.13.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.13.45
+Version: 3.13.47
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.45 → tina4_python-3.13.47}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.45"
+version = "3.13.47"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.45 → tina4_python-3.13.47}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.13.45"
+__version__ = "3.13.47"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.13.45 → tina4_python-3.13.47}/tina4_python/core/router.py

@@ -219,18 +219,17 @@ class Router:
         """Register a global middleware class applied to every route.
 
         Equivalent to decorating every handler with @middleware(middleware_class).
+        Delegates to the single ``Middleware`` global registry that the request
+        dispatcher actually consults — mirrors PHP ``Router::use`` ->
+        ``Middleware::use``, Ruby ``Router.use`` -> ``Middleware.use`` and the
+        Node equivalent. (Before #55 this wrote to a private ``Router._global_middleware``
+        list that nothing read, so globals registered via ``Router.use`` never ran.)
 
         Args:
             middleware_class: A class with before_*/after_* static methods.
         """
-        from tina4_python.core import middleware as _mw_module  # avoid circular import
-        if hasattr(_mw_module, "register_global"):
-            _mw_module.register_global(middleware_class)
-        else:
-            # Fallback: store in a module-level list the dispatcher can pick up.
-            if not hasattr(cls, "_global_middleware"):
-                cls._global_middleware = []
-            cls._global_middleware.append(middleware_class)
+        from tina4_python.core.middleware import Middleware  # avoid circular import
+        Middleware.use(middleware_class)
 
     @classmethod
     def get(cls, path: str, handler, middleware: list = None, swagger_meta: dict = None, template: str = None, **options) -> "RouteRef":

{tina4_python-3.13.45 → tina4_python-3.13.47}/tina4_python/core/server.py

@@ -127,10 +127,19 @@ def _auto_discover(root_dir: str = "src"):
                 importlib.import_module(module_name)
                 _discovered_mtimes[module_name] = current_mtime
                 Log.debug(f"Loaded: {module_name}")
-            elif current_mtime > _discovered_mtimes.get(module_name, 0.0):
-                # Changed module — re-execute so edits to an existing route
-                # take effect in-process. Scope guard: only ever evict a module
-                # that lives under our discovery package. Deleting a
+            elif module_name not in _discovered_mtimes:
+                # Already in sys.modules but NEVER recorded by discovery — it was
+                # imported TRANSITIVELY (e.g. `from src.x import y` pulled it in
+                # before the walk reached its file). Record its current mtime as
+                # the baseline WITHOUT re-importing. Re-importing here would
+                # del+re-add a fresh module object, while the earlier importer
+                # keeps the STALE one — module-level singletons would silently
+                # diverge (issue #53). We only ever reload a module WE loaded.
+                _discovered_mtimes[module_name] = current_mtime
+            elif current_mtime > _discovered_mtimes[module_name]:
+                # Changed since WE loaded it — re-execute so edits to an existing
+                # route take effect in-process. Scope guard: only ever evict a
+                # module that lives under our discovery package. Deleting a
                 # tina4_python.* / third-party module would break shared
                 # singletons and class identity — never do that here.
                 if module_name == root_pkg or module_name.startswith(root_pkg + "."):
@@ -1322,6 +1331,28 @@ def _middleware_500(response: Response, mw_inst, method_name: str, error: Except
     })
 
 
+def _effective_middleware(route: dict) -> list:
+    """Resolve the middleware that actually runs for a route.
+
+    Global middleware (registered via ``Middleware.use`` / ``Router.use``) runs
+    on EVERY route, BEFORE the route's own middleware, in registration order.
+    The list is deduped (by class) so a class that is both global and attached
+    to the route runs once. This is the fix for issue #55 — globals were
+    registered into ``Middleware._global_middleware`` but the dispatcher only
+    ever iterated ``route["middleware"]``, so global middleware never ran.
+    Mirrors the PHP/Ruby/Node dispatchers, which already fold globals in.
+    """
+    from tina4_python.core.middleware import Middleware
+    resolved = []
+    seen = set()
+    for mw in list(Middleware.get_global()) + list(route.get("middleware", [])):
+        key = mw if isinstance(mw, type) else type(mw)
+        if key not in seen:
+            seen.add(key)
+            resolved.append(mw)
+    return resolved
+
+
 def _run_before_middleware(request: Request, response: Response, route: dict) -> tuple[Request, Response, bool]:
     """Run class-based before_* middleware methods. Returns (request, response, skip_handler).
 
@@ -1338,7 +1369,7 @@ def _run_before_middleware(request: Request, response: Response, route: dict) ->
     before_* that sets status >= 400 also short-circuits the handler.
     """
     skip = False
-    for _mw_cls in route.get("middleware", []):
+    for _mw_cls in _effective_middleware(route):
         if _is_function_middleware(_mw_cls):
             continue  # Handled by the continuation wrapper instead
         _mw_inst = _mw_cls() if isinstance(_mw_cls, type) else _mw_cls
@@ -1378,7 +1409,7 @@ def _run_after_middleware(request: Request, response: Response, route: dict) ->
     Resilience (M2): each after_* call is wrapped — a method that THROWS is
     logged and converted to a clean 500; remaining after_* still run.
     """
-    for _mw_cls in route.get("middleware", []):
+    for _mw_cls in _effective_middleware(route):
         if _is_function_middleware(_mw_cls):
             continue
         _mw_inst = _mw_cls() if isinstance(_mw_cls, type) else _mw_cls

{tina4_python-3.13.45 → tina4_python-3.13.47}/tina4_python/database/sqlite.py

@@ -93,23 +93,43 @@ class SQLiteAdapter(DatabaseAdapter):
             )
 
     def execute_many(self, sql: str, params_list: list[list] = None) -> DatabaseResult:
-        """Optimized batch execute using SQLite's executemany."""
+        """Optimized batch execute using SQLite's executemany — ATOMIC (one txn).
+
+        The batch runs inside one transaction so a bad row mid-batch rolls the
+        WHOLE batch back (all-or-nothing) instead of leaving the rows applied
+        before the failure in an open, uncommitted transaction. Mirrors the base
+        DatabaseAdapter.execute_many owns-transaction guard and the other engines.
+        """
         sql = self._translate_sql(sql)
         rows = params_list or []
-        self._conn.executemany(sql, rows)
-
-        # cursor.rowcount / cursor.lastrowid are unreliable after executemany()
-        # in sqlite3 (rowcount can come back 0 or -1, lastrowid is not set) and
-        # were non-deterministic across pooled connections. The batch is
-        # all-or-raise, so every supplied row was applied; the last inserted id
-        # is read deterministically from last_insert_rowid() on this connection.
-        affected = len(rows)
-        last_row = self._conn.execute("SELECT last_insert_rowid()").fetchone()
-        last_id = last_row[0] if last_row and last_row[0] else None
-
-        if not self._in_transaction and self.autocommit:
-            if self._conn.in_transaction:
-                self._conn.execute("COMMIT")
+
+        # Own (and commit/rollback) the batch transaction only for a standalone
+        # write in autocommit mode — never inside a caller's explicit transaction.
+        standalone = self.autocommit and not self._in_transaction
+        if standalone and not self._conn.in_transaction:
+            self._conn.execute("BEGIN")
+
+        try:
+            self._conn.executemany(sql, rows)
+            # cursor.rowcount / cursor.lastrowid are unreliable after executemany()
+            # in sqlite3 (rowcount can come back 0 or -1, lastrowid is not set).
+            # The batch is all-or-nothing, so every supplied row was applied; read
+            # the last inserted id deterministically from last_insert_rowid().
+            affected = len(rows)
+            last_row = self._conn.execute("SELECT last_insert_rowid()").fetchone()
+            last_id = last_row[0] if last_row and last_row[0] else None
+        except Exception:
+            # Roll the partial batch back so nothing is left half-applied, then
+            # FAIL LOUD (re-raise) — parity with execute() and the other engines.
+            if standalone and self._conn.in_transaction:
+                try:
+                    self._conn.execute("ROLLBACK")
+                except Exception:
+                    pass
+            raise
+
+        if standalone and self._conn.in_transaction:
+            self._conn.execute("COMMIT")
 
         return DatabaseResult(
             affected_rows=affected,

{tina4_python-3.13.45 → tina4_python-3.13.47}/tina4_python/migration/runner.py

@@ -332,59 +332,137 @@ def _normalize_quotes(sql: str) -> str:
 
 
 def _split_statements(sql: str, delimiter: str = ";") -> list[str]:
-    """Split SQL into individual statements.
-
-    Handles:
-    - Line comments (-- ...)
-    - Block comments (/* ... */)
-    - Empty statements
-    - Stored procedure blocks delimited by $$ or //
-      Example:
-          CREATE TRIGGER foo $$ BEGIN ... END $$;
-          CREATE PROCEDURE bar // BEGIN ... END //;
+    """Split SQL into individual statements with a single-pass, quote- and
+    comment-aware scanner.
+
+    The split decision is made character by character so the delimiter only ever
+    fires in real statement position. This is the fix for issue #54: the old
+    implementation split on ``delimiter`` BEFORE stripping ``-- …`` line comments,
+    so a ``;`` *inside* a line comment fragmented one statement into several
+    broken pieces. A scanner that knows where it is — code, comment, or string —
+    cannot make that mistake.
+
+    Handled, in priority order, only when NOT already inside a stored-proc block:
+
+    - **Stored-procedure blocks** delimited by ``$$`` or ``//`` are kept intact
+      (their inner ``;`` never splits). A ``//`` preceded by ``:`` is a URL
+      scheme (``https://…``), not a block delimiter, so it is left alone.
+    - **Block comments** ``/* … */`` are stripped.
+    - **Line comments** ``-- …`` are stripped to end of line (the newline is
+      kept, so line structure survives). A ``;`` here never splits.
+    - **String literals** — single-quoted ``'…'`` and double-quoted identifiers
+      ``"…"`` — are copied verbatim, honouring the SQL doubled-quote escape
+      (``''`` / ``""``). A ``;``, ``--`` or ``/*`` inside a literal is data, not
+      a delimiter or comment, so it is preserved untouched.
+    - The **delimiter** ends a statement only when reached outside all of the
+      above. Empty statements are dropped; each kept statement is trimmed.
+
+    Smart/curly quotes are normalized to straight ASCII first. Mirrors the
+    tina4-php ``Migration::splitStatements`` scanner for cross-framework parity.
     """
     # Normalize smart/curly quotes to straight ASCII first, so SQL pasted from
     # an editor/doc (which converts " → “ ” and ' → ‘ ’) actually runs.
     sql = _normalize_quotes(sql)
 
-    # Extract blocks delimited by $$ or // first, replacing them with placeholders
-    blocks: list[str] = []
-
-    def _save_block(m):
-        blocks.append(m.group(0))
-        return f"__BLOCK_{len(blocks) - 1}__"
-
-    # Match $$ ... $$ or // ... // blocks (stored procedures, triggers, etc.).
-    # The `//` delimiters must NOT be preceded by a colon, so a URL scheme
-    # (`https://…`) or other `://` literal inside a migration is never captured
-    # as an opaque stored-proc block (it would otherwise swallow everything
-    # between two `//` occurrences and skip statement splitting/cleaning).
-    processed = re.sub(r"\$\$(.*?)\$\$", _save_block, sql, flags=re.DOTALL)
-    processed = re.sub(r"(?<!:)//(.*?)(?<!:)//", _save_block, processed, flags=re.DOTALL)
-
-    # Remove block comments (but not inside stored proc blocks)
-    clean = re.sub(r"/\*.*?\*/", "", processed, flags=re.DOTALL)
-
-    statements = []
-    for stmt in clean.split(delimiter):
-        # Remove line comments and blank lines
-        lines = []
-        for line in stmt.split("\n"):
-            stripped = line.strip()
-            if stripped and not stripped.startswith("--"):
-                # Remove inline comments (-- after SQL)
-                comment_pos = line.find("--")
-                if comment_pos >= 0:
-                    line = line[:comment_pos]
-                lines.append(line)
-        cleaned = "\n".join(lines).strip()
-
-        # Restore block placeholders
-        for i, block in enumerate(blocks):
-            cleaned = cleaned.replace(f"__BLOCK_{i}__", block)
-
-        if cleaned:
-            statements.append(cleaned)
+    statements: list[str] = []
+    current: list[str] = []
+    n = len(sql)
+    dlen = len(delimiter)
+    i = 0
+    in_dollar_block = False
+    in_slash_block = False
+
+    while i < n:
+        ch = sql[i]
+
+        # $$ … $$ stored-proc block (toggle in/out).
+        if not in_slash_block and ch == "$" and i + 1 < n and sql[i + 1] == "$":
+            current.append("$$")
+            i += 2
+            in_dollar_block = not in_dollar_block
+            continue
+
+        # // … // stored-proc block (toggle). The `//` must NOT be preceded by a
+        # colon, so a URL scheme (`https://…`) or any `://` literal is never
+        # treated as a block delimiter (it would otherwise swallow everything
+        # between two `//` occurrences and skip statement splitting).
+        if (not in_dollar_block and ch == "/" and i + 1 < n and sql[i + 1] == "/"
+                and not (i > 0 and sql[i - 1] == ":")):
+            current.append("//")
+            i += 2
+            in_slash_block = not in_slash_block
+            continue
+
+        # Inside a stored-proc block: consume verbatim (inner ; never splits).
+        if in_dollar_block or in_slash_block:
+            current.append(ch)
+            i += 1
+            continue
+
+        # Block comment /* … */ — stripped.
+        if ch == "/" and i + 1 < n and sql[i + 1] == "*":
+            end = sql.find("*/", i + 2)
+            i = (end + 2) if end != -1 else n
+            continue
+
+        # Line comment -- … — stripped to end of line; the newline is left for
+        # the next iteration so line structure (and statement boundaries on the
+        # NEXT line) survive. A ';' inside the comment is NOT a delimiter.
+        if ch == "-" and i + 1 < n and sql[i + 1] == "-":
+            end = sql.find("\n", i + 2)
+            i = end if end != -1 else n
+            continue
+
+        # Single-quoted string literal — '' escapes a quote. Copied verbatim so a
+        # ';' / '--' / '/*' inside the value is data, not a delimiter/comment.
+        if ch == "'":
+            current.append("'")
+            i += 1
+            while i < n:
+                if sql[i] == "'" and i + 1 < n and sql[i + 1] == "'":
+                    current.append("''")
+                    i += 2
+                elif sql[i] == "'":
+                    current.append("'")
+                    i += 1
+                    break
+                else:
+                    current.append(sql[i])
+                    i += 1
+            continue
+
+        # Double-quoted identifier — "" escapes a quote. Same verbatim handling.
+        if ch == '"':
+            current.append('"')
+            i += 1
+            while i < n:
+                if sql[i] == '"' and i + 1 < n and sql[i + 1] == '"':
+                    current.append('""')
+                    i += 2
+                elif sql[i] == '"':
+                    current.append('"')
+                    i += 1
+                    break
+                else:
+                    current.append(sql[i])
+                    i += 1
+            continue
+
+        # Statement delimiter — only reached outside blocks/comments/strings.
+        if delimiter and sql.startswith(delimiter, i):
+            stmt = "".join(current).strip()
+            if stmt:
+                statements.append(stmt)
+            current = []
+            i += dlen
+            continue
+
+        current.append(ch)
+        i += 1
+
+    stmt = "".join(current).strip()
+    if stmt:
+        statements.append(stmt)
     return statements
 
 

{tina4_python-3.13.45 → tina4_python-3.13.47}/tina4_python/scss/__init__.py

@@ -131,6 +131,9 @@ def _compile(scss: str) -> str:
     # 6. Resolve @extend
     scss = _resolve_extends(scss, placeholders)
 
+    # 6.5. Resolve #{ ... } interpolation (before $var substitution + nesting).
+    scss = _resolve_interpolation(scss, variables)
+
     # 7. Substitute variables
     scss = _substitute_variables(scss, variables)
 
@@ -171,6 +174,27 @@ def _substitute_variables(scss: str, variables: dict) -> str:
     return scss
 
 
+def _resolve_interpolation(scss: str, variables: dict) -> str:
+    """Resolve SCSS ``#{ ... }`` interpolation.
+
+    Each ``#{ expr }`` is replaced by its resolved inner text: a ``$variable``
+    inside the braces resolves to its value, anything else is inlined verbatim
+    (trimmed). This lets a value carry a variable inside a string context the
+    plain ``$var`` substitution can't reach — e.g. ``calc(100% - #{$gap})`` ->
+    ``calc(100% - 20px)`` — and lets a variable appear in a selector
+    (``.icon-#{$name}`` -> ``.icon-home``). Run BEFORE nested-rule flattening so
+    the literal ``{``/``}`` never confuse the block matcher. The inner cannot
+    contain braces (interpolation is a leaf expression), so ``[^{}]*`` is safe.
+    """
+    def _resolve(m):
+        inner = m.group(1).strip()
+        for name in sorted(variables.keys(), key=len, reverse=True):
+            inner = inner.replace(f"${name}", variables[name])
+        return inner
+
+    return re.sub(r'#\{([^{}]*)\}', _resolve, scss)
+
+
 def _extract_mixins(scss: str, mixins: dict) -> str:
     """Extract @mixin definitions."""
     pattern = re.compile(