execsql2 2.16.1__tar.gz → 2.16.2__tar.gz

{execsql2-2.16.1 → execsql2-2.16.2}/CHANGELOG.md

@@ -13,6 +13,14 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.16.2] - 2026-04-30
+
+### Fixed
+
+- INCLUDE with quoted paths (e.g., `-- !x! INCLUDE "!!path!!/file.sql"`) now strips the surrounding quotes before resolving the file path. The AST parser captured the full target text including quotes, but the legacy dispatch regex stripped them — quoted INCLUDE paths would fail with "File does not exist" even when the file was present on disk.
+
+______________________________________________________________________
+
 ## [2.16.1] - 2026-04-30
 
 ### Fixed

{execsql2-2.16.1 → execsql2-2.16.2}/CONTRIBUTING.md

@@ -24,26 +24,6 @@ uv tool install rust-just  # via uv
 
 Run `just` with no arguments to list all available recipes.
 
-```
-just sync          # Sync dependencies from lockfile
-just update-hooks  # Update pre-commit hooks to latest versions
-
-just lint          # Run ruff linter + formatter
-just pre-commit    # Run all pre-commit hooks against every file
-just test          # Run tests against the active Python version
-just test-all      # Run tests across all supported Python versions (3.10–3.13)
-just clean         # Remove build artifacts and caches
-
-just docs          # Build the documentation site
-just docs-serve    # Serve docs locally at http://127.0.0.1:8000
-
-just bump          # Show available version bumps from current version
-just bump-patch    # Bump patch version  (e.g. 2.0.0 → 2.0.1)
-just bump-minor    # Bump minor version  (e.g. 2.0.0 → 2.1.0)
-just bump-major    # Bump major version  (e.g. 2.0.0 → 3.0.0)
-just bump-pre 2.0.0a1  # Tag a specific pre-release version
-```
-
 ## Code Quality
 
 Linting and formatting are handled by [ruff](https://docs.astral.sh/ruff/):

{execsql2-2.16.1 → execsql2-2.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: execsql2
-Version: 2.16.1
+Version: 2.16.2
 Summary: Runs a SQL script against a PostgreSQL, SQLite, MariaDB/MySQL, DuckDB, Firebird, MS-Access, MS-SQL-Server, or Oracle database, or an ODBC DSN. Provides metacommands to import and export data, copy data between databases, conditionally execute SQL and metacommands, and dynamically alter SQL and metacommands with substitution variables.
 Project-URL: Homepage, https://execsql2.readthedocs.io
 Project-URL: Repository, https://github.com/geocoug/execsql

{execsql2-2.16.1 → execsql2-2.16.2}/docs/about/divergence.md

@@ -312,6 +312,7 @@ These are behavioral changes driven by security or correctness issues in the ups
 | Temp file creation TOCTOU race                      | `TempFileMgr.new_temp_fn()` discarded the `NamedTemporaryFile` handle, creating a race window. Now uses `tempfile.mkstemp()` for secure creation. Inherited from upstream.                                                                                                                                                                                                                                                                                                                                                                                 |
 | `shlex.split` on Windows incorrect mode             | Called without `posix=False` on Windows, mishandling backslash-heavy paths in SHELL commands. Inherited from upstream.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | AST executor `~`/`+` variable scoping broken        | The AST executor passed `localvars` through function parameters but never pushed `CommandList` frames onto `commandliststack`. Legacy metacommand handlers (`x_sub`, `x_rm_sub`, `xf_sub_defined`, `SUB_LOCAL`, prompt handlers, REPL) access `commandliststack[-1]` for `~` local and `+` outer-scope variables. This caused `~` vars to be invisible to SQL, `SUB_DEFINED(~var)` to always return false, and the REPL `.vars`/`.stack` to show empty state. Fixed by pushing/popping `CommandList` frames in `execute()` and `_execute_script_native()`. |
+| AST parser INCLUDE quoted paths broken              | The AST parser captured the full INCLUDE target including surrounding quotes (`"path"`), but the legacy dispatch regex stripped them. Quoted INCLUDE paths failed with "File does not exist" even when the file was present. Fixed by stripping matched quote pairs in the parser.                                                                                                                                                                                                                                                                         |
 
 ______________________________________________________________________
 

{execsql2-2.16.1 → execsql2-2.16.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.16.1"
+version = "2.16.2"
 description = "Runs a SQL script against a PostgreSQL, SQLite, MariaDB/MySQL, DuckDB, Firebird, MS-Access, MS-SQL-Server, or Oracle database, or an ODBC DSN. Provides metacommands to import and export data, copy data between databases, conditionally execute SQL and metacommands, and dynamically alter SQL and metacommands with substitution variables."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { file = "LICENSE.txt" }
@@ -165,7 +165,7 @@ skip-magic-trailing-comma = false
 line-ending = "auto"
 
 [tool.bumpversion]
-current_version = "2.16.1"
+current_version = "2.16.2"
 commit = true
 tag = true
 tag_name = "v{new_version}"

{execsql2-2.16.1 → execsql2-2.16.2}/src/execsql/script/executor.py

@@ -760,6 +760,11 @@ def _execute_include_native(
     effective_locals = _stack_localvars(ctx) or localvars
     target = substitute_vars(node.target, effective_locals, ctx=ctx).strip()
 
+    # Strip surrounding quotes — the AST parser captures the full target
+    # including any quotes, but the legacy dispatch regex stripped them.
+    if len(target) >= 2 and target[0] in ('"', "'") and target[-1] == target[0]:
+        target = target[1:-1]
+
     # Tilde expansion (matches x_include legacy handler)
     if len(target) > 1 and target[0] == "~" and target[1] == os.sep:
         target = str(Path.home() / target[2:])

{execsql2-2.16.1 → execsql2-2.16.2}/src/execsql/script/parser.py

@@ -95,6 +95,14 @@ _INCLUDE_RX = re.compile(
     re.I,
 )
 
+
+def _strip_quotes(s: str) -> str:
+    """Strip a matching pair of surrounding quotes from *s*."""
+    if len(s) >= 2 and s[0] in ('"', "'") and s[-1] == s[0]:
+        return s[1:-1]
+    return s
+
+
 _EXEC_SCRIPT_RX = re.compile(
     r"^\s*(?:EXEC(?:UTE)?|RUN)\s+SCRIPT"
     r"(?P<exists>\s+IF\s+EXISTS)?"
@@ -545,7 +553,7 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
                 _current_body().append(
                     IncludeDirective(
                         span=SourceSpan(source_name, file_lineno),
-                        target=m.group("target").strip(),
+                        target=_strip_quotes(m.group("target").strip()),
                         if_exists=m.group("exists") is not None,
                     ),
                 )

{execsql2-2.16.1 → execsql2-2.16.2}/tests/cli/test_cli_run.py

@@ -22,7 +22,7 @@ from unittest.mock import MagicMock, patch
 import pytest
 
 import execsql.state as _state
-from execsql.cli.run import _connect_initial_db, _print_dry_run, _run
+from execsql.cli.run import _apply_cli_options, _connect_initial_db, _print_dry_run, _run, _seed_early_subvars
 from execsql.exceptions import ConfigError
 
 
@@ -1312,3 +1312,175 @@ class TestPositionalNetworkRouting:
             )
         # server set by DSN, positional should go to db
         assert _state.conf.db == "extra_db"
+
+
+# ---------------------------------------------------------------------------
+# _seed_early_subvars — unit tests for exception/filter branches
+# ---------------------------------------------------------------------------
+
+
+class TestSeedEarlySubvars:
+    """Unit tests for _seed_early_subvars() covering the sensitive-key filter
+    and the exception-swallowing branch for invalid env-var names."""
+
+    def test_sensitive_key_filtered_out(self):
+        """Env vars whose names contain a sensitive substring are not seeded.
+
+        This exercises the ``continue`` branch (line 211 in run.py) where a key
+        such as ``MY_SECRET_KEY`` is skipped before ``add_substitution`` is called.
+        """
+        with patch.dict("os.environ", {"MY_SECRET_KEY": "s3cr3t"}, clear=False):
+            subvars = _seed_early_subvars()
+        # The sensitive var must not appear with the & prefix.
+        assert subvars.varvalue("&MY_SECRET_KEY") is None
+        assert subvars.varvalue("&my_secret_key") is None
+
+    def test_invalid_env_var_name_is_silently_skipped(self):
+        """An env var whose name produces an invalid substitution key does not raise.
+
+        Keys that contain characters outside word-character range (e.g. a hyphen)
+        produce a variable name like ``&MY-VAR`` which fails SubVarSet.check_var_name().
+        The ``except Exception: pass`` block (lines 214-215) swallows the error.
+        """
+        # Use a key containing a hyphen — illegal in an execsql variable name.
+        with patch.dict("os.environ", {"EXECSQL-INVALID-KEY": "value"}, clear=False):
+            # Must not raise even though add_substitution will raise ErrInfo.
+            subvars = _seed_early_subvars()
+        # The variable should simply be absent from the internal dict rather than
+        # causing a crash.  Check the internal dict directly to avoid calling
+        # varvalue() with an invalid key (which would itself raise).
+        assert "&execsql-invalid-key" not in subvars._subs_dict
+
+
+# ---------------------------------------------------------------------------
+# _apply_cli_options — unit tests for default-fallback branches
+# ---------------------------------------------------------------------------
+
+
+class TestApplyCliOptionsDefaults:
+    """Unit tests for _apply_cli_options() that exercise the default-value
+    fallback branches.  These branches are only reachable when conf fields are
+    ``None`` (i.e. not set by ConfigData defaults), which never happens when
+    going through _run() — hence these tests call _apply_cli_options() directly
+    with a hand-crafted SimpleNamespace conf.
+    """
+
+    def _conf(self, **kwargs):
+        """Return a minimal SimpleNamespace conf with all relevant fields set to
+        ``None`` so that every default-fallback branch in _apply_cli_options()
+        becomes reachable."""
+        defaults = {
+            "username": None,
+            "passwd_prompt": True,
+            "db_encoding": None,
+            "script_encoding": None,
+            "output_encoding": None,
+            "import_encoding": None,
+            "import_buffer": None,
+            "make_export_dirs": None,
+            "boolean_int": None,
+            "scan_lines": None,
+            "gui_level": None,
+            "gui_framework": None,
+            "db_type": None,
+            "user_logfile": False,
+            "port": None,
+            "access_username": None,
+            "new_db": False,
+            "export_output_dir": None,
+            "show_progress": False,
+        }
+        defaults.update(kwargs)
+        return SimpleNamespace(**defaults)
+
+    def _call(self, conf, **kwargs):
+        """Invoke _apply_cli_options() with the supplied conf and kwargs,
+        filling in None/False defaults for any omitted parameters."""
+        defaults = {
+            "user": None,
+            "no_passwd": False,
+            "database_encoding": None,
+            "script_encoding": None,
+            "output_encoding": None,
+            "import_encoding": None,
+            "import_buffer": None,
+            "make_dirs": None,
+            "boolean_int": None,
+            "scanlines": None,
+            "use_gui": None,
+            "gui_framework": None,
+            "db_type": None,
+            "user_logfile": False,
+            "port": None,
+            "new_db": False,
+            "output_dir": None,
+            "progress": False,
+        }
+        defaults.update(kwargs)
+        _apply_cli_options(conf, **defaults)
+
+    def test_script_encoding_defaults_to_utf8_when_conf_is_none(self):
+        """When conf.script_encoding is None and no CLI flag is given, default to 'utf8'."""
+        conf = self._conf(script_encoding=None)
+        self._call(conf, script_encoding=None)
+        assert conf.script_encoding == "utf8"
+
+    def test_output_encoding_defaults_to_utf8_when_conf_is_none(self):
+        """When conf.output_encoding is None and no CLI flag is given, default to 'utf8'."""
+        conf = self._conf(output_encoding=None)
+        self._call(conf, output_encoding=None)
+        assert conf.output_encoding == "utf8"
+
+    def test_import_encoding_defaults_to_utf8_when_conf_is_none(self):
+        """When conf.import_encoding is None and no CLI flag is given, default to 'utf8'."""
+        conf = self._conf(import_encoding=None)
+        self._call(conf, import_encoding=None)
+        assert conf.import_encoding == "utf8"
+
+    def test_scan_lines_defaults_to_100_when_conf_is_none(self):
+        """When conf.scan_lines is None and scanlines CLI arg is None, default to 100."""
+        conf = self._conf(scan_lines=None)
+        self._call(conf, scanlines=None)
+        assert conf.scan_lines == 100
+
+    def test_db_type_defaults_to_l_when_conf_is_none(self):
+        """When conf.db_type is None and db_type CLI arg is None, default to 'l' (SQLite)."""
+        conf = self._conf(db_type=None)
+        self._call(conf, db_type=None)
+        assert conf.db_type == "l"
+
+    def test_gui_level_out_of_range_raises_config_error(self):
+        """A gui_level value outside 0-3 raises ConfigError after being set by use_gui."""
+        conf = self._conf(gui_level=None)
+        with pytest.raises(ConfigError, match="Invalid GUI level"):
+            self._call(conf, use_gui="5")
+
+    def test_cli_script_encoding_overrides_none_conf(self):
+        """A CLI-supplied script_encoding wins over None in conf."""
+        conf = self._conf(script_encoding=None)
+        self._call(conf, script_encoding="latin-1")
+        assert conf.script_encoding == "latin-1"
+
+    def test_cli_output_encoding_overrides_none_conf(self):
+        """A CLI-supplied output_encoding wins over None in conf."""
+        conf = self._conf(output_encoding=None)
+        self._call(conf, output_encoding="cp1252")
+        assert conf.output_encoding == "cp1252"
+
+    def test_cli_import_encoding_overrides_none_conf(self):
+        """A CLI-supplied import_encoding wins over None in conf."""
+        conf = self._conf(import_encoding=None)
+        self._call(conf, import_encoding="utf-16")
+        assert conf.import_encoding == "utf-16"
+
+    def test_cli_scanlines_overrides_none_conf(self):
+        """A CLI-supplied scanlines wins over None in conf (no default applied)."""
+        conf = self._conf(scan_lines=None)
+        self._call(conf, scanlines=500)
+        assert conf.scan_lines == 500
+
+    def test_cli_db_type_overrides_none_conf(self):
+        """A CLI-supplied db_type wins over None in conf."""
+        conf = self._conf(db_type=None)
+        self._call(conf, db_type="p")
+        assert conf.db_type == "p"

{execsql2-2.16.1 → execsql2-2.16.2}/tests/test_executor.py

@@ -616,6 +616,26 @@ class TestInclude:
         assert result.returncode == 0
         assert _query_db(tmp_path, "SELECT x FROM t") == [(99,)]
 
+    def test_include_quoted_path(self, tmp_path):
+        """INCLUDE with double-quoted path strips quotes correctly."""
+        included = tmp_path / "helper.sql"
+        included.write_text("INSERT INTO t VALUES (7);")
+        script = 'CREATE TABLE t (x INT);\n-- !x! INCLUDE "helper.sql"'
+        result = _run_ast(script, tmp_path)
+        assert result.returncode == 0, result.stderr
+        assert _query_db(tmp_path, "SELECT x FROM t") == [(7,)]
+
+    def test_include_quoted_path_with_vars(self, tmp_path):
+        """INCLUDE with quoted path containing substitution variables."""
+        subdir = tmp_path / "lib"
+        subdir.mkdir()
+        included = subdir / "helper.sql"
+        included.write_text("INSERT INTO t VALUES (8);")
+        script = f'-- !x! SUB mylib {subdir}\nCREATE TABLE t (x INT);\n-- !x! INCLUDE "!!mylib!!!!$pathsep!!helper.sql"'
+        result = _run_ast(script, tmp_path)
+        assert result.returncode == 0, result.stderr
+        assert _query_db(tmp_path, "SELECT x FROM t") == [(8,)]
+
     def test_include_if_exists_missing(self, tmp_path):
         """INCLUDE IF EXISTS silently skips missing files."""
         script = "CREATE TABLE t (x INT);\nINSERT INTO t VALUES (1);\n-- !x! INCLUDE IF EXISTS no_such_file.sql"

{execsql2-2.16.1 → execsql2-2.16.2}/tests/test_plugins.py

@@ -11,9 +11,12 @@ from execsql.plugins import (
     ImporterEntry,
     ImporterRegistry,
     _load_entry_points,
+    discover_all_plugins,
     discover_exporter_plugins,
     discover_importer_plugins,
     discover_metacommand_plugins,
+    get_exporter_registry,
+    get_importer_registry,
 )
 
 
@@ -211,3 +214,122 @@ class TestListPluginsCli:
             result = runner.invoke(app, ["--list-plugins"], catch_exceptions=False)
             assert result.exit_code == 0
             assert "my_awesome_plugin" in result.output
+
+
+# ---------------------------------------------------------------------------
+# ImporterRegistry — untested methods
+# ---------------------------------------------------------------------------
+
+
+class TestImporterRegistryMethods:
+    def test_formats_returns_sorted_uppercase(self):
+        reg = ImporterRegistry()
+        reg.add("zebra", import_fn=lambda: None)
+        reg.add("alpha", import_fn=lambda: None)
+        assert reg.formats() == ["ALPHA", "ZEBRA"]
+
+    def test_entries_returns_all(self):
+        reg = ImporterRegistry()
+        reg.add("a", import_fn=lambda: None)
+        reg.add("b", import_fn=lambda: None)
+        assert len(reg.entries()) == 2
+
+
+# ---------------------------------------------------------------------------
+# Module-level singletons
+# ---------------------------------------------------------------------------
+
+
+class TestRegistrySingletons:
+    def test_get_exporter_registry_returns_instance(self):
+        import execsql.plugins as _plugins
+
+        # Reset global to ensure we exercise the None-branch.
+        original = _plugins._exporter_registry
+        _plugins._exporter_registry = None
+        try:
+            reg = get_exporter_registry()
+            assert isinstance(reg, ExporterRegistry)
+            # Second call returns the same singleton.
+            assert get_exporter_registry() is reg
+        finally:
+            _plugins._exporter_registry = original
+
+    def test_get_importer_registry_returns_instance(self):
+        import execsql.plugins as _plugins
+
+        original = _plugins._importer_registry
+        _plugins._importer_registry = None
+        try:
+            reg = get_importer_registry()
+            assert isinstance(reg, ImporterRegistry)
+            assert get_importer_registry() is reg
+        finally:
+            _plugins._importer_registry = original
+
+
+# ---------------------------------------------------------------------------
+# _load_entry_points — error branch when entry_points() itself raises
+# ---------------------------------------------------------------------------
+
+
+class TestLoadEntryPointsError:
+    def test_entry_points_query_failure_returns_empty(self):
+        """If entry_points() raises, _load_entry_points should return []."""
+        with patch("execsql.plugins.entry_points", side_effect=RuntimeError("registry broken")):
+            result = _load_entry_points(METACOMMAND_GROUP)
+            assert result == []
+
+
+# ---------------------------------------------------------------------------
+# discover_all_plugins
+# ---------------------------------------------------------------------------
+
+
+class TestDiscoverAllPlugins:
+    def test_discover_all_plugins_without_mcl_skips_metacommands(self):
+        """When mcl is None, metacommand plugins are not attempted."""
+        with patch("execsql.plugins.entry_points", return_value=[]):
+            result = discover_all_plugins(mcl=None)
+        # Key for metacommand group must be absent since mcl is None.
+        from execsql.plugins import METACOMMAND_GROUP
+
+        assert METACOMMAND_GROUP not in result
+        # Exporter and importer counts are present.
+        from execsql.plugins import EXPORTER_GROUP, IMPORTER_GROUP
+
+        assert EXPORTER_GROUP in result
+        assert IMPORTER_GROUP in result
+
+    def test_discover_all_plugins_with_mcl_includes_metacommands(self):
+        """When mcl is provided, all three plugin types are discovered."""
+        mock_mcl = MagicMock()
+        with patch("execsql.plugins.entry_points", return_value=[]):
+            result = discover_all_plugins(mcl=mock_mcl)
+        from execsql.plugins import EXPORTER_GROUP, IMPORTER_GROUP, METACOMMAND_GROUP
+
+        assert METACOMMAND_GROUP in result
+        assert EXPORTER_GROUP in result
+        assert IMPORTER_GROUP in result
+
+    def test_discover_exporter_plugin_registration_error_handled(self):
+        """A plugin whose register function raises does not crash discover_exporter_plugins."""
+        mock_register = MagicMock(side_effect=ValueError("bad exporter"))
+        mock_ep = MagicMock()
+        mock_ep.name = "broken_exp"
+        mock_ep.load.return_value = mock_register
+
+        with patch("execsql.plugins.entry_points", return_value=[mock_ep]):
+            count = discover_exporter_plugins()
+        assert count == 0
+
+    def test_discover_importer_plugin_registration_error_handled(self):
+        """A plugin whose register function raises does not crash discover_importer_plugins."""
+        mock_register = MagicMock(side_effect=ValueError("bad importer"))
+        mock_ep = MagicMock()
+        mock_ep.name = "broken_imp"
+        mock_ep.load.return_value = mock_register
+
+        with patch("execsql.plugins.entry_points", return_value=[mock_ep]):
+            count = discover_importer_plugins()
+        assert count == 0

{execsql2-2.16.1 → execsql2-2.16.2}/tests/utils/test_strings.py

@@ -222,3 +222,8 @@ class TestEncodingsMatch:
 
     def test_koi8r_aliases(self):
         assert encodings_match("koi8-r", "koi8r") is True
+
+    def test_leading_zero_normalization_matches(self):
+        # iso-8859-01 and iso-8859-1 differ only in a leading zero — the
+        # numeric-leading-zero stripping pass (line 133-137 in run.py) makes them equal.
+        assert encodings_match("iso-8859-01", "iso-8859-1") is True

{execsql2-2.16.1 → execsql2-2.16.2}/uv.lock

@@ -648,7 +648,7 @@ wheels = [
 
 [[package]]
 name = "execsql2"
-version = "2.16.1"
+version = "2.16.2"
 source = { editable = "." }
 dependencies = [
     { name = "python-dateutil" },