Fix spelling.

src/pytsql/tsql.py

@@ -40,13 +40,13 @@ def _process_replacement(line: str, parameters: dict[str, Any]) -> str:
     return new_line
 
 
-def _parametrize(
+def _parameterize(
     source: str,
     parameters: dict[str, Any],
     start: str = _REPLACE_START,
     end: str = _REPLACE_END,
 ) -> str:
-    """Replace all {start} and {end} statements, i.e. parametrizes the SQL script.
+    """Replace all {start} and {end} statements, i.e. parameterizes the SQL script.
 
     Parameters
     ----------
@@ -57,19 +57,19 @@ def _parametrize(
         the input source code, separated by newlines, with parameter replacements
     """
 
-    def parametrization_replacer(match: Match) -> str:
+    def parameterization_replacer(match: Match) -> str:
         return _process_replacement(match.group(1), parameters)
 
-    # The pattern matches all parametrization patterns, including those within a string literal.
+    # The pattern matches all parameterization patterns, including those within a string literal.
     pattern = re.compile(
         rf"/\* {re.escape(start)} \*/.*?/\* {re.escape(end)}(.*?) \*/",
         re.DOTALL | re.MULTILINE,
     )
 
-    parametrized = re.sub(pattern, parametrization_replacer, source)
+    parameterized = re.sub(pattern, parameterization_replacer, source)
 
     non_empty_stripped_lines = [
-        x.strip() for x in parametrized.split("\n") if x.strip() != ""
+        x.strip() for x in parameterized.split("\n") if x.strip() != ""
     ]
 
     return "\n".join(non_empty_stripped_lines)
@@ -235,13 +235,13 @@ def executes(
     None
 
     """
-    parametrized_code = _parametrize(code, parameters) if parameters else code
+    parameterized_code = _parameterize(code, parameters) if parameters else code
     with engine.connect().execution_options(isolation_level="AUTOCOMMIT") as conn:
         # Since the prints table is a temporary one, it will be local to the connection and it will be dropped once the
         # connection is closed. Caveat: sqlalchemy engines can pool connections, so we still have to drop it preemtively.
         conn.execute(_text(f"DROP TABLE IF EXISTS {_PRINTS_TABLE}"))
         conn.execute(_text(f"CREATE TABLE {_PRINTS_TABLE} (p NVARCHAR(4000))"))
-        for batch in _split(parametrized_code, isolate_top_level_statements):
+        for batch in _split(parameterized_code, isolate_top_level_statements):
             sql_batch = _text(batch)
             conn.execute(sql_batch)
             _fetch_and_clear_prints(conn)

tests/unit/test_parametrize.py → tests/unit/test_parameterize.py

@@ -1,6 +1,6 @@
 import pytest
 
-from pytsql.tsql import _parametrize
+from pytsql.tsql import _parameterize
 
 
 def test_replace_comment():
@@ -14,7 +14,7 @@ def test_replace_comment():
 /* </replace> select {alpha},b,{charlie} from x */
     """  # noqa: W291
     expected = """select first,b,second from x"""
-    assert _parametrize(seed, {"alpha": "first", "charlie": "second"}) == expected
+    assert _parameterize(seed, {"alpha": "first", "charlie": "second"}) == expected
 
 
 def test_replace_comment_second():
@@ -26,7 +26,7 @@ def test_replace_comment_second():
     """
     expected = """USE master;
 select * from [master].[dbo].[new_table];"""
-    assert _parametrize(seed, {"tableName": "new_table"}) == expected
+    assert _parameterize(seed, {"tableName": "new_table"}) == expected
 
 
 def test_replace_comment_int():
@@ -38,7 +38,7 @@ def test_replace_comment_int():
     """
     expected = """USE master;
 select top 1337 * from [master].[dbo].[table];"""
-    assert _parametrize(seed, {"n_rows": 1337}) == expected
+    assert _parameterize(seed, {"n_rows": 1337}) == expected
 
 
 def test_replace_comment_class():
@@ -57,7 +57,7 @@ def __str__(self):
     """
     expected = """USE master;
 select * from master.dbo.table;"""
-    assert _parametrize(seed, {"table_qualifier": MyClass("table")}) == expected
+    assert _parameterize(seed, {"table_qualifier": MyClass("table")}) == expected
 
 
 def test_none_replacement():
@@ -68,7 +68,7 @@ def test_none_replacement():
 /* </replace> select * from [master].[dbo].[{tableName}]; */
     """
     with pytest.raises(ValueError):
-        _parametrize(seed, {"tableName": None})
+        _parameterize(seed, {"tableName": None})
 
 
 def test_double_replacement():
@@ -84,7 +84,7 @@ def test_double_replacement():
 FROM dbo.new_table t1
 JOIN dbo.new_table t2
 ON t1.id = t2.id;"""  # noqa: W291
-    assert _parametrize(seed, {"tableName": "new_table"}) == expected
+    assert _parameterize(seed, {"tableName": "new_table"}) == expected
 
 
 def test_multiline_replacement():
@@ -96,7 +96,7 @@ def test_multiline_replacement():
     """
     expected = """USE master;
 select * from [master].[dbo].[new_table];"""
-    assert _parametrize(seed, {"tableName": "new_table"}) == expected
+    assert _parameterize(seed, {"tableName": "new_table"}) == expected
 
 
 def test_multi_multiline_replacements():
@@ -115,7 +115,7 @@ def test_multi_multiline_replacements():
 USE newTable;
 select * from [master].[dbo].[second_table];"""  # noqa: W291
     assert (
-        _parametrize(seed, {"tableName": "new_table", "otherTable": "second_table"})
+        _parameterize(seed, {"tableName": "new_table", "otherTable": "second_table"})
         == expected
     )
 
@@ -127,7 +127,7 @@ def test_regular_comment_stays():
     """
     expected = """USE master; /* this is a regular comment */
 select * from [master].[dbo].[table];"""
-    assert _parametrize(seed, {"branch": "new_master"}) == expected
+    assert _parameterize(seed, {"branch": "new_master"}) == expected
 
 
 def test_unknown_parameter_exception():
@@ -138,15 +138,15 @@ def test_unknown_parameter_exception():
 select * from [master].[dbo].[table];
     """
     with pytest.raises(KeyError):
-        _parametrize(seed, {"key": "value"})
+        _parameterize(seed, {"key": "value"})
 
 
 def test_same_line_replacement():
     seed = """
 select a,b,/* <replace> */c/* </replace>{otherC} */ from x
     """
     expected = """select a,b,newC from x"""
-    assert _parametrize(seed, {"otherC": "newC"}) == expected
+    assert _parameterize(seed, {"otherC": "newC"}) == expected
 
 
 def test_multi_same_line_replacements():
@@ -156,12 +156,12 @@ def test_multi_same_line_replacements():
     """
     expected = """SELECT newA, newB
 FROM table;"""
-    assert _parametrize(seed, {"newA": "newA", "newB": "newB"}) == expected
+    assert _parameterize(seed, {"newA": "newA", "newB": "newB"}) == expected
 
 
 def test_replace_in_string_literal():
     seed = """SELECT '/* <replace> */a/* </replace>{newA} */'"""
-    assert _parametrize(seed, {"newA": "newA"}) == "SELECT 'newA'"
+    assert _parameterize(seed, {"newA": "newA"}) == "SELECT 'newA'"
 
 
 def test_custom_replace_keywords():
@@ -170,7 +170,7 @@ def test_custom_replace_keywords():
         """
     expected = """SELECT a,/* <replace> */b/* </replace>{otherB} */,newC FROM x"""
     assert (
-        _parametrize(
+        _parameterize(
             seed,
             {"otherB": "newB", "otherC": "newC"},
             start="*repl_start*",