activerecord-pg-format-db-structure 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdde773cae9c0a23f2fe42d4a1016f3498d37a616dece4e3477fc8e839869243
-  data.tar.gz: 9d55b019c0938e3c4c6ba1f008adb542b9a156c1ab73bd50b4157a65c6bbf128
+  metadata.gz: 1b2d206493754a88a3913e3fb7e3532364f2adbd0dea689226d73d9544c73e98
+  data.tar.gz: df009fb052c07eb578b063785ee2186bfbda7ccd758643ae52285b99c784b49b
 SHA512:
-  metadata.gz: 6ef698a4873b63ba33863576481eaa858d8363c3acbc37011b0f3c023f120a5783e572995ad3a27a1c57faaef35ba86d6eefd57207313cad0eefb1b21f33253c
-  data.tar.gz: 142c1205e34fc069cc4a26f0957f9ca76ba142e6012914e7af06d0f47ef84700648c25339757da936b74cfe898e8f4d3b577ecff85bbcfa35cf57f39685fb2fb
+  metadata.gz: 9e519793dec134c227413416d750ef8be1d3da7414c921369022fc663ae4ae75b789de632e18cd1f08cfa85e719cd87a0b2ed61336db7130e01094196fcb1823
+  data.tar.gz: 64558806595fdecbe27035f5c22b8f3c90b56909a5a2a19b20a1fe6cf2cdbd5dac153cf5d9d860e5ee372144cea5609751b5b1f52dd41072586830a1ae93109e

data/.rubocop.yml

@@ -24,6 +24,12 @@ Metrics/MethodLength:
 Metrics/AbcSize:
   Enabled: false
 
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
 RSpec/SpecFilePathFormat:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.1.2] - 2025-01-30
+
+- Get rid of `anbt-sql-formatter` dependency since it breaks queries with type casting
+
+## [0.1.1] - 2025-01-29
+
+- Proper deparsing of all statements
+- Formatting of select and insert sub-statements using `anbt-sql-formatter`
+
 ## [0.1.0] - 2025-01-24
 
 - Initial release

data/README.md

@@ -182,9 +182,9 @@ INSERT INTO "schema_migrations" (version) VALUES
 into this much more compact and normalized version:
 
 ```sql
--- Name: pgcrypto; Type: EXTENSION
 
-CREATE EXTENSION IF NOT EXISTS pgcrypto WITH SCHEMA public;
+
+CREATE EXTENSION IF NOT EXISTS pgcrypto SCHEMA public;
 
 
 -- Name: comments; Type: TABLE;
@@ -219,8 +219,10 @@ ALTER TABLE ONLY public.comments
   ADD CONSTRAINT fk_rails_0000000001 FOREIGN KEY (post_id) REFERENCES public.posts (id),
   ADD CONSTRAINT fk_rails_0000000002 FOREIGN KEY (user_id) REFERENCES public.users (id);
 
-INSERT INTO "schema_migrations" (version) VALUES
-('20250124155339');
+
+INSERT INTO schema_migrations (version) VALUES
+ ('20250124155339')
+;
 ```
 
 which is a lot more compact, easier to read, and reduces the risk of
@@ -334,13 +336,9 @@ Should be run after other operations that inline alter statements.
 
 ## Deparser
 
-As of today, this is a bare implemenation that works with the current combination of tranformers.
-
-As of now, it will only deparse `CREATE TABLE`, `CREATE INDEX` and
-`ALTER TABLE` statements. Other statements will be kept unchanged from
-the input SQL.
+Returns an SQL string from raw PgQuery statements.
 
-In order to support all statements, we will need to find a solution to more cleanly format SQL queries, as deparsing a `CREATE VIEW` statement will result in a single unreadable line if relying on `pg_query`.
+Relying mostly on `PgQuery.deparse`, and does a best effort to add some indentation where possible.
 
 ## Development
 

data/lib/activerecord-pg-format-db-structure/deparser.rb

@@ -7,6 +7,8 @@ module ActiveRecordPgFormatDbStructure
   class Deparser
     attr_reader :source
 
+    PRETTY_INDENT_STRING = "    "
+
     def initialize(source)
       @source = source
     end
@@ -19,17 +21,29 @@ module ActiveRecordPgFormatDbStructure
         deparse_index_stmt(raw_statement.stmt.index_stmt)
       in stmt: { alter_table_stmt: _ }
         deparse_alter_table_stmt(raw_statement.stmt.alter_table_stmt)
+      in stmt: { select_stmt: _ }
+        deparse_select_stmt(raw_statement.stmt.select_stmt)
+      in stmt: { insert_stmt: _ }
+        deparse_insert_statement(raw_statement.stmt.insert_stmt)
+      in stmt: { create_table_as_stmt: _ }
+        deparse_create_table_as_stmt(raw_statement.stmt.create_table_as_stmt)
+      in stmt: { view_stmt: _ }
+        deparse_view_stmt(raw_statement.stmt.view_stmt)
       else
-        keep_original_string(raw_statement)
+        "\n#{deparse_stmt(raw_statement.stmt.inner)}"
       end
     end
 
     private
 
-    def keep_original_string(raw_statement)
-      start = raw_statement.stmt_location || 0
-      stop = start + raw_statement.stmt_len
-      source[start..stop]
+    def deparse_stmt(stmt)
+      "\n#{PgQuery.deparse_stmt(stmt)};"
+    end
+
+    def deparse_select_stmt(select_stmt)
+      generic_query_str = +"\n\n"
+      generic_query_str << deparse_leaf_select_stmt(select_stmt)
+      generic_query_str << ";"
     end
 
     def deparse_index_stmt(index_stmt)
@@ -37,40 +51,195 @@ module ActiveRecordPgFormatDbStructure
     end
 
     def deparse_alter_table_stmt(alter_table_stmt)
-      "\n#{
-        deparse_stmt(alter_table_stmt)
-          .gsub(" ADD ", "\n  ADD ")
-          .gsub(" ALTER COLUMN ", "\n  ALTER COLUMN ")
-      }"
+      alter_table_str = +"\n\n"
+      alter_table_str << PgQuery.deparse_stmt(
+        PgQuery::AlterTableStmt.new(
+          **alter_table_stmt.to_h,
+          cmds: []
+        )
+      ).chomp(" ")
+
+      alter_table_cmds_str = alter_table_stmt.cmds.map do |cmd|
+        "\n  #{deparse_alter_table_cmd(cmd)}"
+      end.join(",")
+
+      alter_table_str << alter_table_cmds_str
+      alter_table_str << ";"
+      alter_table_str
     end
 
-    def deparse_stmt(stmt)
-      "\n#{PgQuery.deparse_stmt(stmt)};"
+    def deparse_alter_table_cmd(cmd)
+      PgQuery.deparse_stmt(
+        PgQuery::AlterTableStmt.new(
+          relation: { relname: "tmp" },
+          cmds: [cmd]
+        )
+      ).gsub(/\AALTER ONLY tmp /, "")
     end
 
     def deparse_create_stmt(create_stmt)
+      placeholder_column = PgQuery::Node.from(
+        PgQuery::ColumnDef.new(
+          colname: "placeholder_column",
+          type_name: {
+            names: [PgQuery::Node.from_string("placeholder_type")]
+          }
+        )
+      )
+
       table_str = "\n\n\n-- Name: #{create_stmt.relation.relname}; Type: TABLE;\n\n"
       table_str << PgQuery.deparse_stmt(
         PgQuery::CreateStmt.new(
           **create_stmt.to_h,
-          table_elts: []
+          table_elts: [placeholder_column]
         )
       )
-      table_str.gsub!(/\(\)\z/, "")
-      table_str << "("
-      table_str << create_stmt.table_elts.map do |elt|
+      table_str << ";"
+
+      table_columns = create_stmt.table_elts.map do |elt|
         "\n    #{deparse_table_elt(elt)}"
       end.join(",")
-      table_str << "\n);"
+      table_columns << "\n"
+
+      table_str[deparse_table_elt(placeholder_column)] = table_columns
+
       table_str
     end
 
     def deparse_table_elt(elt)
       PgQuery.deparse_stmt(
         PgQuery::CreateStmt.new(
-          relation: PgQuery::RangeVar.new(relname: "tmp"), table_elts: [elt]
+          relation: { relname: "tmp" }, table_elts: [elt]
+        )
+      ).gsub(/\ACREATE TABLE ONLY tmp \((.*)\)\z/, '\1')
+    end
+
+    def deparse_create_table_as_stmt(stmt)
+      create_table_as_stmt_str = +"\n\n"
+      create_table_as_stmt_str << PgQuery.deparse_stmt(
+        PgQuery::CreateTableAsStmt.new(
+          **stmt.to_h,
+          query: PgQuery::Node.from(placeholder_query_stmt)
+        )
+      )
+      create_table_as_stmt_str << ";"
+
+      query_str = +"(\n"
+      query_str << deparse_leaf_select_stmt(stmt.query.select_stmt).gsub(/^/, PRETTY_INDENT_STRING)
+      query_str << "\n)"
+
+      create_table_as_stmt_str[placeholder_query_string] = query_str
+      create_table_as_stmt_str
+    end
+
+    def deparse_view_stmt(stmt)
+      view_stmt_str = +"\n\n"
+      view_stmt_str << PgQuery.deparse_stmt(
+        PgQuery::ViewStmt.new(
+          **stmt.to_h,
+          query: PgQuery::Node.from(placeholder_query_stmt)
         )
-      ).sub(/\ACREATE TABLE ONLY tmp \(/, "").sub(/\)\z/, "")
+      )
+      view_stmt_str << ";"
+
+      query_str = +"(\n"
+      query_str << deparse_leaf_select_stmt(stmt.query.select_stmt).gsub(/^/, PRETTY_INDENT_STRING)
+      query_str << "\n)"
+
+      view_stmt_str[placeholder_query_string] = query_str
+      view_stmt_str
+    end
+
+    def deparse_insert_statement(insert_stmt)
+      insert_stmt_str = +"\n\n\n"
+      insert_stmt_str << PgQuery.deparse_stmt(
+        PgQuery::InsertStmt.new(
+          **insert_stmt.to_h,
+          select_stmt: PgQuery::Node.from(placeholder_query_stmt)
+        )
+      )
+      insert_stmt_str << "\n;"
+
+      query_str = if insert_stmt.select_stmt.inner.values_lists.any?
+                    deparse_values_list_select_stmt(insert_stmt.select_stmt.inner)
+                  else
+                    deparse_leaf_select_stmt(insert_stmt.select_stmt.inner)
+                  end
+
+      insert_stmt_str[placeholder_query_string] = query_str
+      insert_stmt_str
+    end
+
+    def deparse_values_list_select_stmt(select_stmt)
+      values_str = +"VALUES\n "
+      values_str << select_stmt.values_lists.map do |values_list|
+        PgQuery.deparse_stmt(PgQuery::SelectStmt.new(values_lists: [values_list])).gsub(/\AVALUES /, "")
+      end.join("\n,")
+      values_str
+    end
+
+    def deparse_leaf_select_stmt(select_stmt) # rubocop:disable Metrics/PerceivedComplexity
+      target_list_placeholder = PgQuery::ResTarget.new(
+        val: { a_const: { sval: { sval: "target_list_placeholder" } } }
+      )
+
+      if select_stmt.with_clause
+        placeholder_with_clause = PgQuery::WithClause.new(
+          **select_stmt.with_clause.to_h,
+          ctes: select_stmt.with_clause.ctes.map do |cte|
+            PgQuery::Node.from(
+              PgQuery::CommonTableExpr.new(
+                **cte.inner.to_h,
+                ctequery: PgQuery::Node.from(placeholder_query_stmt("placeholder_for_#{cte.inner.ctename}_cte"))
+              )
+            )
+          end
+        )
+      end
+
+      select_stmt_str = PgQuery.deparse_stmt(
+        PgQuery::SelectStmt.new(
+          **select_stmt.to_h,
+          with_clause: placeholder_with_clause,
+          target_list: ([PgQuery::Node.from(target_list_placeholder)] if select_stmt.target_list.any?)
+        )
+      )
+
+      if select_stmt.target_list.any?
+        target_list_str = +"\n"
+        target_list_str << select_stmt.target_list.map do |target|
+          deparse_res_target(target.inner).gsub(/^/, PRETTY_INDENT_STRING)
+        end.join(",\n")
+        target_list_str << "\n"
+
+        select_stmt_str[deparse_res_target(target_list_placeholder)] = target_list_str
+      end
+
+      select_stmt.with_clause&.ctes&.each do |cte|
+        cte_str = +"\n"
+        cte_str << deparse_leaf_select_stmt(cte.inner.ctequery.inner).gsub(/^/, PRETTY_INDENT_STRING)
+        cte_str << "\n"
+
+        select_stmt_str["SELECT placeholder_for_#{cte.inner.ctename}_cte"] = cte_str
+      end
+
+      select_stmt_str.gsub!(/ +$/, "")
+
+      select_stmt_str
+    end
+
+    def deparse_res_target(res_target)
+      PgQuery.deparse_stmt(
+        PgQuery::SelectStmt.new(target_list: [PgQuery::Node.from(res_target)])
+      ).gsub(/\ASELECT /, "")
+    end
+
+    def placeholder_query_string(placeholder_name = "placeholder")
+      PgQuery.deparse_stmt(placeholder_query_stmt(placeholder_name))
+    end
+
+    def placeholder_query_stmt(placeholder_name = "placeholder")
+      PgQuery.parse("SELECT #{placeholder_name}").tree.stmts.first.stmt.select_stmt
     end
   end
 end

data/lib/activerecord-pg-format-db-structure/transforms/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "pg_query"
+
+module ActiveRecordPgFormatDbStructure
+  module Transforms
+    # :nodoc:
+    class Base
+      attr_reader :raw_statements
+
+      def initialize(raw_statements)
+        @raw_statements = raw_statements
+      end
+    end
+  end
+end

data/lib/activerecord-pg-format-db-structure/transforms/group_alter_table_statements.rb

@@ -1,18 +1,12 @@
 # frozen_string_literal: true
 
-require "pg_query"
+require_relative "base"
 
 module ActiveRecordPgFormatDbStructure
   module Transforms
     # Group alter table statements into one operation per
     # table. Should be run after other operations that inline alter statements.
-    class GroupAlterTableStatements
-      attr_reader :raw_statements
-
-      def initialize(raw_statements)
-        @raw_statements = raw_statements
-      end
-
+    class GroupAlterTableStatements < Base
       def transform!
         alter_groups = extract_alter_table_statements!
 

data/lib/activerecord-pg-format-db-structure/transforms/inline_constraints.rb

@@ -1,27 +1,20 @@
 # frozen_string_literal: true
 
-require "pg_query"
+require_relative "base"
 
 module ActiveRecordPgFormatDbStructure
   module Transforms
     # Inline non-foreign key constraints into table declaration
-    class InlineConstraints
-      attr_reader :raw_statements
-
-      def initialize(raw_statements)
-        @raw_statements = raw_statements
-        @tables_with_constraint = {}
-      end
-
+    class InlineConstraints < Base
       def transform!
-        extract_constraints_to_inline!
+        tables_with_constraint = extract_constraints_to_inline!
         raw_statements.each do |raw_statement|
           next unless raw_statement.stmt.to_h in create_stmt: { relation: { schemaname:, relname: }}
 
           relation = { schemaname:, relname: }
-          next unless @tables_with_constraint.include?(relation)
+          next unless tables_with_constraint.include?(relation)
 
-          @tables_with_constraint[relation].each do |constraint|
+          tables_with_constraint[relation].each do |constraint|
             add_constraint!(raw_statement, constraint)
           end
         end
@@ -30,14 +23,16 @@ module ActiveRecordPgFormatDbStructure
       private
 
       def extract_constraints_to_inline!
+        tables_with_constraint = {}
         raw_statements.delete_if do |raw_statement|
           next unless match_alter_column_statement(raw_statement) in { table:, constraint: }
 
-          @tables_with_constraint[table] ||= []
-          @tables_with_constraint[table] << constraint
+          tables_with_constraint[table] ||= []
+          tables_with_constraint[table] << constraint
 
           true
         end
+        tables_with_constraint
       end
 
       def match_alter_column_statement(raw_statement)
@@ -68,8 +63,8 @@ module ActiveRecordPgFormatDbStructure
       end
 
       def add_constraint!(raw_statement, constraint)
-        raw_statement.stmt.create_stmt.table_elts << PgQuery::Node.new(
-          constraint: PgQuery::Constraint.new(constraint)
+        raw_statement.stmt.create_stmt.table_elts << PgQuery::Node.from(
+          PgQuery::Constraint.new(constraint)
         )
       end
     end

data/lib/activerecord-pg-format-db-structure/transforms/inline_foreign_keys.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "pg_query"
+require_relative "base"
 
 module ActiveRecordPgFormatDbStructure
   module Transforms
@@ -9,23 +9,16 @@ module ActiveRecordPgFormatDbStructure
     # Note: using this transform makes the structure file no longer
     # loadable, since tables should be created before a foreign key
     # can target it.
-    class InlineForeignKeys
-      attr_reader :raw_statements
-
-      def initialize(raw_statements)
-        @raw_statements = raw_statements
-        @columns_with_foreign_key = {}
-      end
-
+    class InlineForeignKeys < Base
       def transform!
-        extract_foreign_keys_to_inline!
+        columns_with_foreign_key = extract_foreign_keys_to_inline!
         raw_statements.each do |raw_statement|
           next unless raw_statement.stmt.to_h in create_stmt: { relation: { schemaname:, relname: }}
 
           relation = { schemaname:, relname: }
-          next unless @columns_with_foreign_key.include?(relation)
+          next unless columns_with_foreign_key.include?(relation)
 
-          @columns_with_foreign_key[relation].each do |column_name, constraint|
+          columns_with_foreign_key[relation].each do |column_name, constraint|
             add_constraint!(raw_statement, column_name, constraint)
           end
         end
@@ -34,15 +27,17 @@ module ActiveRecordPgFormatDbStructure
       private
 
       def extract_foreign_keys_to_inline!
+        columns_with_foreign_key = {}
         raw_statements.delete_if do |raw_statement|
           next unless match_alter_column_statement(raw_statement) in { column:, constraint: }
 
           table = column.except(:colname)
-          @columns_with_foreign_key[table] ||= {}
-          @columns_with_foreign_key[table][column[:colname]] = constraint
+          columns_with_foreign_key[table] ||= {}
+          columns_with_foreign_key[table][column[:colname]] = constraint
 
           true
         end
+        columns_with_foreign_key
       end
 
       def match_alter_column_statement(raw_statement)
@@ -99,8 +94,8 @@ module ActiveRecordPgFormatDbStructure
         raw_statement.stmt.create_stmt.table_elts.each do |table_elt|
           next unless table_elt.to_h in { column_def: { colname: ^colname } }
 
-          table_elt.column_def.constraints << PgQuery::Node.new(
-            constraint: PgQuery::Constraint.new(constraint)
+          table_elt.column_def.constraints << PgQuery::Node.from(
+            PgQuery::Constraint.new(constraint)
           )
         end
       end

data/lib/activerecord-pg-format-db-structure/transforms/inline_primary_keys.rb

@@ -1,25 +1,18 @@
 # frozen_string_literal: true
 
-require "pg_query"
+require_relative "base"
 
 module ActiveRecordPgFormatDbStructure
   module Transforms
     # Inlines primary keys with the table declaration
-    class InlinePrimaryKeys
-      attr_reader :raw_statements
-
-      def initialize(raw_statements)
-        @raw_statements = raw_statements
-        @columns_with_primary_key = {}
-      end
-
+    class InlinePrimaryKeys < Base
       def transform!
-        extract_primary_keys_to_inline!
+        columns_with_primary_key = extract_primary_keys_to_inline!
         raw_statements.each do |raw_statement|
           next unless raw_statement.stmt.to_h in create_stmt: { relation: { schemaname:, relname: }}
 
           relation = { schemaname:, relname: }
-          primary_key = @columns_with_primary_key[relation]
+          primary_key = columns_with_primary_key[relation]
           add_primary_key!(raw_statement, primary_key) if primary_key
         end
       end
@@ -27,15 +20,17 @@ module ActiveRecordPgFormatDbStructure
       private
 
       def extract_primary_keys_to_inline!
+        columns_with_primary_key = {}
         raw_statements.delete_if do |raw_statement|
           next unless match_alter_column_statement(raw_statement) in { schemaname:, relname:, colname: }
 
           column = { schemaname:, relname:, colname: }
           table = column.except(:colname)
-          @columns_with_primary_key[table] = column[:colname]
+          columns_with_primary_key[table] = column[:colname]
 
           true
         end
+        columns_with_primary_key
       end
 
       def match_alter_column_statement(raw_statement)
@@ -73,10 +68,8 @@ module ActiveRecordPgFormatDbStructure
             c.to_h in { constraint: { contype: :CONSTR_NOTNULL } }
           end
 
-          table_elt.column_def.constraints << PgQuery::Node.new(
-            constraint: PgQuery::Constraint.new(
-              contype: :CONSTR_PRIMARY
-            )
+          table_elt.column_def.constraints << PgQuery::Node.from(
+            PgQuery::Constraint.new(contype: :CONSTR_PRIMARY)
           )
         end
       end

data/lib/activerecord-pg-format-db-structure/transforms/inline_serials.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "pg_query"
+require_relative "base"
 
 module ActiveRecordPgFormatDbStructure
   module Transforms
@@ -13,25 +13,17 @@ module ActiveRecordPgFormatDbStructure
     # It also assumes that the associated sequence has default settings. A
     # later version could try to be more strict / validate that the
     # sequence indeed has default settings.
-    class InlineSerials
-      attr_reader :raw_statements
-
-      def initialize(raw_statements)
-        @raw_statements = raw_statements
-        @columns_to_replace_with_serial = {}
-        @sequences_to_remove = Set.new
-      end
-
+    class InlineSerials < Base
       def transform!
-        extract_serials_to_inline!
-        delete_redundant_statements!
+        extract_serials_to_inline! => columns_to_replace_with_serial:, sequences_to_remove:
+        delete_redundant_statements!(sequences_to_remove)
         raw_statements.each do |raw_statement|
           next unless raw_statement.stmt.to_h in create_stmt: { relation: { schemaname:, relname: }}
 
           relation = { schemaname:, relname: }
-          next unless @columns_to_replace_with_serial.include?(relation)
+          next unless columns_to_replace_with_serial.include?(relation)
 
-          @columns_to_replace_with_serial[relation].each do |colname|
+          columns_to_replace_with_serial[relation].each do |colname|
             replace_id_with_serial!(raw_statement, colname)
           end
         end
@@ -40,16 +32,19 @@ module ActiveRecordPgFormatDbStructure
       private
 
       def extract_serials_to_inline!
+        columns_to_replace_with_serial = {}
+        sequences_to_remove = Set.new
         raw_statements.delete_if do |raw_statement|
           next unless match_alter_column_statement(raw_statement) in { column:, sequence: }
 
           table = column.except(:column_name)
-          @columns_to_replace_with_serial[table] ||= []
-          @columns_to_replace_with_serial[table] << column[:column_name]
-          @sequences_to_remove << sequence
+          columns_to_replace_with_serial[table] ||= []
+          columns_to_replace_with_serial[table] << column[:column_name]
+          sequences_to_remove << sequence
 
           true
         end
+        { columns_to_replace_with_serial:, sequences_to_remove: }
       end
 
       def match_alter_column_statement(raw_statement)
@@ -107,21 +102,21 @@ module ActiveRecordPgFormatDbStructure
 
           table_elt.column_def.type_name = PgQuery::TypeName.new(
             names: [
-              PgQuery::Node.new(string: PgQuery::String.new(
-                sval: COLUMN_TYPE_TO_SERIAL_TYPE.fetch(integer_type)
-              ))
+              PgQuery::Node.from_string(
+                COLUMN_TYPE_TO_SERIAL_TYPE.fetch(integer_type)
+              )
             ]
           )
         end
       end
 
-      def delete_redundant_statements!
+      def delete_redundant_statements!(sequences_to_remove)
         raw_statements.delete_if do |raw_statement|
           case raw_statement.stmt.to_h
           in create_seq_stmt: { sequence: { schemaname:, relname: }}
-            @sequences_to_remove.include?({ schemaname:, relname: })
+            sequences_to_remove.include?({ schemaname:, relname: })
           in alter_seq_stmt: {sequence: { schemaname:, relname: }}
-            @sequences_to_remove.include?({ schemaname:, relname: })
+            sequences_to_remove.include?({ schemaname:, relname: })
           else
             false
           end

data/lib/activerecord-pg-format-db-structure/transforms/move_indices_after_create_table.rb

@@ -1,17 +1,11 @@
 # frozen_string_literal: true
 
-require "pg_query"
+require_relative "base"
 
 module ActiveRecordPgFormatDbStructure
   module Transforms
     # Move indice declaration just below the table they index
-    class MoveIndicesAfterCreateTable
-      attr_reader :raw_statements
-
-      def initialize(raw_statements)
-        @raw_statements = raw_statements
-      end
-
+    class MoveIndicesAfterCreateTable < Base
       def transform!
         extract_table_indices!.each do |table, indices|
           insert_index = find_insert_index(**table)

data/lib/activerecord-pg-format-db-structure/transforms/remove_comments_on_extensions.rb

@@ -1,17 +1,11 @@
 # frozen_string_literal: true
 
-require "pg_query"
+require_relative "base"
 
 module ActiveRecordPgFormatDbStructure
   module Transforms
     # Remove COMMENT statement applied to extensions
-    class RemoveCommentsOnExtensions
-      attr_reader :raw_statements
-
-      def initialize(raw_statements)
-        @raw_statements = raw_statements
-      end
-
+    class RemoveCommentsOnExtensions < Base
       def transform!
         raw_statements.delete_if do |raw_statement|
           raw_statement.stmt.to_h in {

data/lib/activerecord-pg-format-db-structure/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordPgFormatDbStructure
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-pg-format-db-structure
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Jell
 bindir: exe
 cert_chain: []
-date: 2025-01-26 00:00:00.000000000 Z
+date: 2025-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_query
@@ -44,6 +44,7 @@ files:
 - lib/activerecord-pg-format-db-structure/preprocessors/remove_whitespaces.rb
 - lib/activerecord-pg-format-db-structure/railtie.rb
 - lib/activerecord-pg-format-db-structure/tasks/clean_db_structure.rake
+- lib/activerecord-pg-format-db-structure/transforms/base.rb
 - lib/activerecord-pg-format-db-structure/transforms/group_alter_table_statements.rb
 - lib/activerecord-pg-format-db-structure/transforms/inline_constraints.rb
 - lib/activerecord-pg-format-db-structure/transforms/inline_foreign_keys.rb