django-migrate-sql-deux 1.2.0__tar.gz → 1.3.0__tar.gz

{django_migrate_sql_deux-1.2.0 → django_migrate_sql_deux-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-migrate-sql-deux
-Version: 1.2.0
+Version: 1.3.0
 Summary: Django Migrations for raw SQL
 Author-email: Bogdan Klichuk <klichukb@gmail.com>, Bruno Alla <oss@browniebroke.com>
 License-Expression: ISC
@@ -181,9 +181,13 @@ Note that
    sql_items = [
        SQLItem(
            'make_sum',   # name of the item
-           'create or replace function make_sum(a int, b int) returns int as $$ '
-           'begin return a + b; end; '
-           '$$ language plpgsql;',  # forward sql
+           """
+           create or replace function make_sum(a int, b int) returns int as $$
+             begin
+               return a + b;
+             end;
+           $$ language plpgsql;
+           """,  # forward sql
            reverse_sql='drop function make_sum(int, int);',  # sql for removal
        ),
    ]
@@ -252,9 +256,13 @@ Now, say, you want to change the function implementation so that it takes a cust
    sql_items = [
        SQLItem(
            "make_sum",  # name of the item
-           "create or replace function make_sum(a mynum, b mynum) returns mynum as $$ "
-           "begin return (a.num + b.num, 'result')::mynum; end;"
-           "$$ language plpgsql;",  # forward sql
+           """
+           create or replace function make_sum(a mynum, b mynum) returns mynum as $$
+             begin
+               return (a.num + b.num, 'result')::mynum;
+             end;
+           $$ language plpgsql;
+           """,  # forward sql
            reverse_sql="drop function make_sum(mynum, mynum);",  # sql for removal
            # depends on `mynum` since takes it as argument. we won't be able to drop function
            # without dropping `mynum` first.

{django_migrate_sql_deux-1.2.0 → django_migrate_sql_deux-1.3.0}/README.md

@@ -151,9 +151,13 @@ Note that
    sql_items = [
        SQLItem(
            'make_sum',   # name of the item
-           'create or replace function make_sum(a int, b int) returns int as $$ '
-           'begin return a + b; end; '
-           '$$ language plpgsql;',  # forward sql
+           """
+           create or replace function make_sum(a int, b int) returns int as $$
+             begin
+               return a + b;
+             end;
+           $$ language plpgsql;
+           """,  # forward sql
            reverse_sql='drop function make_sum(int, int);',  # sql for removal
        ),
    ]
@@ -222,9 +226,13 @@ Now, say, you want to change the function implementation so that it takes a cust
    sql_items = [
        SQLItem(
            "make_sum",  # name of the item
-           "create or replace function make_sum(a mynum, b mynum) returns mynum as $$ "
-           "begin return (a.num + b.num, 'result')::mynum; end;"
-           "$$ language plpgsql;",  # forward sql
+           """
+           create or replace function make_sum(a mynum, b mynum) returns mynum as $$
+             begin
+               return (a.num + b.num, 'result')::mynum;
+             end;
+           $$ language plpgsql;
+           """,  # forward sql
            reverse_sql="drop function make_sum(mynum, mynum);",  # sql for removal
            # depends on `mynum` since takes it as argument. we won't be able to drop function
            # without dropping `mynum` first.

{django_migrate_sql_deux-1.2.0 → django_migrate_sql_deux-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "setuptools>=77.0.3" ]
 
 [project]
 name = "django-migrate-sql-deux"
-version = "1.2.0"
+version = "1.3.0"
 description = "Django Migrations for raw SQL"
 readme = "README.md"
 license = "ISC"

django_migrate_sql_deux-1.3.0/src/django_migrate_sql/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.3.0"

{django_migrate_sql_deux-1.2.0 → django_migrate_sql_deux-1.3.0}/src/django_migrate_sql/config.py

@@ -1,3 +1,6 @@
+import textwrap
+
+
 class SQLItem:
     """
     Represents any SQL entity (unit), for example function, type, index or trigger.
@@ -21,7 +24,31 @@ class SQLItem:
 
         """
         self.name = name
-        self.sql = sql
-        self.reverse_sql = reverse_sql
+        self.sql = self._process_sql(sql)
+        self.reverse_sql = self._process_sql(reverse_sql)
         self.dependencies = dependencies or []
         self.replace = replace
+
+    def _process_sql(self, sql):
+        """
+        Process SQL by applying textwrap.dedent() to strings.
+
+        Args:
+            sql (str/tuple/list): SQL string or tuple/list of (sql, params).
+
+        Returns:
+            Processed SQL in the same format as input.
+
+        """
+        if isinstance(sql, str):
+            return textwrap.dedent(sql)
+        if isinstance(sql, (tuple, list)):
+            return [
+                (textwrap.dedent(item[0]), item[1])
+                if isinstance(item, (tuple, list))
+                else textwrap.dedent(item)
+                if isinstance(item, str)
+                else item
+                for item in sql
+            ]
+        return sql

{django_migrate_sql_deux-1.2.0 → django_migrate_sql_deux-1.3.0}/src/django_migrate_sql_deux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-migrate-sql-deux
-Version: 1.2.0
+Version: 1.3.0
 Summary: Django Migrations for raw SQL
 Author-email: Bogdan Klichuk <klichukb@gmail.com>, Bruno Alla <oss@browniebroke.com>
 License-Expression: ISC
@@ -181,9 +181,13 @@ Note that
    sql_items = [
        SQLItem(
            'make_sum',   # name of the item
-           'create or replace function make_sum(a int, b int) returns int as $$ '
-           'begin return a + b; end; '
-           '$$ language plpgsql;',  # forward sql
+           """
+           create or replace function make_sum(a int, b int) returns int as $$
+             begin
+               return a + b;
+             end;
+           $$ language plpgsql;
+           """,  # forward sql
            reverse_sql='drop function make_sum(int, int);',  # sql for removal
        ),
    ]
@@ -252,9 +256,13 @@ Now, say, you want to change the function implementation so that it takes a cust
    sql_items = [
        SQLItem(
            "make_sum",  # name of the item
-           "create or replace function make_sum(a mynum, b mynum) returns mynum as $$ "
-           "begin return (a.num + b.num, 'result')::mynum; end;"
-           "$$ language plpgsql;",  # forward sql
+           """
+           create or replace function make_sum(a mynum, b mynum) returns mynum as $$
+             begin
+               return (a.num + b.num, 'result')::mynum;
+             end;
+           $$ language plpgsql;
+           """,  # forward sql
            reverse_sql="drop function make_sum(mynum, mynum);",  # sql for removal
            # depends on `mynum` since takes it as argument. we won't be able to drop function
            # without dropping `mynum` first.

{django_migrate_sql_deux-1.2.0 → django_migrate_sql_deux-1.3.0}/src/django_migrate_sql_deux.egg-info/SOURCES.txt

@@ -15,5 +15,6 @@ src/django_migrate_sql_deux.egg-info/SOURCES.txt
 src/django_migrate_sql_deux.egg-info/dependency_links.txt
 src/django_migrate_sql_deux.egg-info/requires.txt
 src/django_migrate_sql_deux.egg-info/top_level.txt
+tests/test_config.py
 tests/test_migrate_command.py
 tests/test_system_checks.py

django_migrate_sql_deux-1.3.0/tests/test_config.py

@@ -0,0 +1,187 @@
+from django_migrate_sql.config import SQLItem
+
+
+def test_dedent_simple_string():
+    """Test that dedent works on a simple indented string."""
+    item = SQLItem(
+        "test_func",
+        """
+        CREATE FUNCTION test() RETURNS int AS $$
+          BEGIN
+            RETURN 1;
+          END;
+        $$ LANGUAGE plpgsql;
+        """,
+        reverse_sql="DROP FUNCTION test();",
+    )
+    # Should remove common leading whitespace
+    assert item.sql.startswith("\nCREATE FUNCTION")
+    assert "  BEGIN" in item.sql
+    assert item.reverse_sql == "DROP FUNCTION test();"
+
+
+def test_dedent_reverse_sql():
+    """Test that dedent works on reverse_sql."""
+    item = SQLItem(
+        "test_func",
+        "CREATE FUNCTION test() RETURNS int AS $$ BEGIN RETURN 1; END; $$ LANGUAGE plpgsql;",
+        reverse_sql="""
+            DROP FUNCTION test();
+        """,
+    )
+    assert item.reverse_sql.strip() == "DROP FUNCTION test();"
+
+
+def test_dedent_with_tuple_sql():
+    """Test that dedent works with tuple format (sql with parameters)."""
+    item = SQLItem(
+        "test_func",
+        [
+            (
+                """
+                CREATE FUNCTION test(min_val int) RETURNS int AS $$
+                  BEGIN
+                    RETURN min_val + %s;
+                  END;
+                $$ LANGUAGE plpgsql;
+                """,
+                [5],
+            )
+        ],
+    )
+    # Should dedent the SQL string in the tuple
+    assert isinstance(item.sql, list)
+    assert len(item.sql) == 1
+    sql_text, params = item.sql[0]
+    assert sql_text.startswith("\nCREATE FUNCTION")
+    assert params == [5]
+
+
+def test_dedent_preserves_single_line():
+    """Test that single-line SQL strings work correctly."""
+    item = SQLItem(
+        "test_func",
+        "CREATE FUNCTION test() RETURNS int AS $$ BEGIN RETURN 1; END; $$ LANGUAGE plpgsql;",
+        reverse_sql="DROP FUNCTION test();",
+    )
+    assert item.sql == "CREATE FUNCTION test() RETURNS int AS $$ BEGIN RETURN 1; END; $$ LANGUAGE plpgsql;"
+    assert item.reverse_sql == "DROP FUNCTION test();"
+
+
+def test_dedent_with_no_indentation():
+    """Test that SQL without indentation is not affected."""
+    sql = "CREATE FUNCTION test() RETURNS int AS $$ BEGIN RETURN 1; END; $$ LANGUAGE plpgsql;"
+    item = SQLItem("test_func", sql, reverse_sql="DROP FUNCTION test();")
+    assert item.sql == sql
+
+
+def test_dedent_with_dependencies():
+    """Test that dedent works with dependencies specified."""
+    item = SQLItem(
+        "test_func",
+        """
+        CREATE FUNCTION test() RETURNS mytype AS $$
+          BEGIN
+            RETURN (1, 'test')::mytype;
+          END;
+        $$ LANGUAGE plpgsql;
+        """,
+        reverse_sql="DROP FUNCTION test();",
+        dependencies=[("test_app", "mytype")],
+    )
+    assert item.sql.startswith("\nCREATE FUNCTION")
+    assert item.dependencies == [("test_app", "mytype")]
+
+
+def test_dedent_with_replace_flag():
+    """Test that dedent works with replace flag."""
+    item = SQLItem(
+        "test_func",
+        """
+        CREATE OR REPLACE FUNCTION test() RETURNS int AS $$
+          BEGIN
+            RETURN 1;
+          END;
+        $$ LANGUAGE plpgsql;
+        """,
+        reverse_sql="DROP FUNCTION test();",
+        replace=True,
+    )
+    assert item.sql.startswith("\nCREATE OR REPLACE FUNCTION")
+    assert item.replace is True
+
+
+def test_dedent_with_list_of_strings():
+    """Test that dedent works with a list containing plain strings (not tuples)."""
+    item = SQLItem(
+        "test_func",
+        [
+            """
+            CREATE FUNCTION test() RETURNS int AS $$
+              BEGIN
+                RETURN 1;
+              END;
+            $$ LANGUAGE plpgsql;
+            """
+        ],
+    )
+    assert isinstance(item.sql, list)
+    assert len(item.sql) == 1
+    assert item.sql[0].startswith("\nCREATE FUNCTION")
+
+
+def test_dedent_with_none_sql():
+    """Test that None sql is handled correctly."""
+    # This tests the edge case where sql might be None
+    # In practice, this shouldn't happen but we test the return sql path
+    item = SQLItem(
+        "test_func",
+        "CREATE FUNCTION test() RETURNS int AS $$ BEGIN RETURN 1; END; $$ LANGUAGE plpgsql;",
+        reverse_sql=None,
+    )
+    assert item.reverse_sql is None
+
+    # Test with integer - should be returned unchanged
+    item = SQLItem(
+        "test_func",
+        123,
+    )
+    assert item.sql == 123
+
+
+def test_dedent_with_list_containing_none():
+    """Test that None in a list is returned as-is without error."""
+    # Test list with None - should be returned unchanged
+    item = SQLItem(
+        "test_func",
+        [None],
+    )
+    assert isinstance(item.sql, list)
+    assert len(item.sql) == 1
+    assert item.sql[0] is None
+
+    # Test mixed list with string, tuple, and None
+    item2 = SQLItem(
+        "test_func2",
+        [
+            """
+            CREATE FUNCTION test() RETURNS int AS $$
+              BEGIN RETURN 1; END;
+            $$ LANGUAGE plpgsql;
+            """,
+            (
+                """
+                CREATE FUNCTION test2() RETURNS int AS $$
+                  BEGIN RETURN 2; END;
+                $$ LANGUAGE plpgsql;
+                """,
+                [],
+            ),
+            None,
+        ],
+    )
+    assert isinstance(item2.sql, list)
+    assert len(item2.sql) == 3
+    assert item2.sql[0].startswith("\nCREATE FUNCTION test()")
+    assert isinstance(item2.sql[1], tuple)
+    assert item2.sql[2] is None

django_migrate_sql_deux-1.2.0/src/django_migrate_sql/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.2.0"