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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b2d206493754a88a3913e3fb7e3532364f2adbd0dea689226d73d9544c73e98
-  data.tar.gz: df009fb052c07eb578b063785ee2186bfbda7ccd758643ae52285b99c784b49b
+  metadata.gz: 9eadcc90f7e5d8ec76f9f9494e7049646bf68ed37df502df31a1dc9fae87d2b6
+  data.tar.gz: bee026074f768393231546155fc52e0d00098cbdec981729a63c5a8d1efeb1c4
 SHA512:
-  metadata.gz: 9e519793dec134c227413416d750ef8be1d3da7414c921369022fc663ae4ae75b789de632e18cd1f08cfa85e719cd87a0b2ed61336db7130e01094196fcb1823
-  data.tar.gz: 64558806595fdecbe27035f5c22b8f3c90b56909a5a2a19b20a1fe6cf2cdbd5dac153cf5d9d860e5ee372144cea5609751b5b1f52dd41072586830a1ae93109e
+  metadata.gz: efe9804695f586ea988faa923d5db83483b0a0e1395bdaaaabd3dcdbd93358d96a7c5a0f7688b5bf1512d4e14d49bf68f46c65000c9700cb3ad8ef7d63094908
+  data.tar.gz: dbdfa7873bd2551f2c1284befbd039c194cc87aaafea7690df8daabc84724c78a06ff3f021940204aa80cdef569566b9c81bfe4cc0aa3aa6180cb7a660e0bb21

data/.rubocop.yml

@@ -15,19 +15,10 @@ Style/StringLiteralsInInterpolation:
 Naming/FileName:
   Enabled: false
 
-Metrics/BlockLength:
+Naming/VariableNumber:
   Enabled: false
 
-Metrics/MethodLength:
-  Enabled: false
-
-Metrics/AbcSize:
-  Enabled: false
-
-Metrics/ClassLength:
-  Enabled: false
-
-Metrics/CyclomaticComplexity:
+Metrics:
   Enabled: false
 
 RSpec/SpecFilePathFormat:

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [0.1.3] - 2025-02-02
+
+- Rework SQL formatting by only adding indentation to deparsed statements
+
 ## [0.1.2] - 2025-01-30
 
 - Get rid of `anbt-sql-formatter` dependency since it breaks queries with type casting

data/README.md

@@ -221,7 +221,7 @@ ALTER TABLE ONLY public.comments
 
 
 INSERT INTO schema_migrations (version) VALUES
- ('20250124155339')
+  ('20250124155339')
 ;
 ```
 

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

@@ -1,245 +1,88 @@
 # frozen_string_literal: true
 
 require "pg_query"
+require_relative "indenter"
 
 module ActiveRecordPgFormatDbStructure
   # Returns a list of SQL strings from a list of PgQuery::RawStmt.
   class Deparser
     attr_reader :source
 
-    PRETTY_INDENT_STRING = "    "
-
     def initialize(source)
       @source = source
     end
 
     def deparse_raw_statement(raw_statement)
       case raw_statement.to_h
+      in stmt: { insert_stmt: _ }
+        deparse_insert_stmt(raw_statement.stmt.insert_stmt)
       in stmt: { create_stmt: _ }
         deparse_create_stmt(raw_statement.stmt.create_stmt)
-      in stmt: { index_stmt: _ }
-        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)
+      in stmt: { create_table_as_stmt: _ }
+        deparse_create_table_as_stmt(raw_statement.stmt.create_table_as_stmt)
+      in stmt: { index_stmt: _ }
+        deparse_stmt_compact(raw_statement.stmt.index_stmt)
       else
-        "\n#{deparse_stmt(raw_statement.stmt.inner)}"
+        deparse_stmt_generic(raw_statement.stmt.inner)
       end
     end
 
     private
 
-    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)
-      deparse_stmt(index_stmt)
+    def deparse_stmt_generic(stmt)
+      generic_str = +"\n\n"
+      generic_str << deparse_stmt_and_indent(stmt)
+      generic_str << ";"
+      generic_str
     end
 
-    def deparse_alter_table_stmt(alter_table_stmt)
-      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
+    def deparse_stmt_compact(stmt)
+      compact_str = +"\n"
+      compact_str << deparse_stmt(stmt)
+      compact_str << ";"
+      compact_str
     end
 
-    def deparse_alter_table_cmd(cmd)
-      PgQuery.deparse_stmt(
-        PgQuery::AlterTableStmt.new(
-          relation: { relname: "tmp" },
-          cmds: [cmd]
-        )
-      ).gsub(/\AALTER ONLY tmp /, "")
+    def deparse_insert_stmt(stmt)
+      insert_str = +"\n\n\n"
+      insert_str << deparse_stmt_and_indent(stmt)
+      insert_str << "\n;"
+      insert_str
     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: [placeholder_column]
-        )
-      )
+    def deparse_create_stmt(stmt)
+      table_str = "\n\n\n-- Name: #{stmt.relation.relname}; Type: TABLE;\n\n"
+      table_str << deparse_stmt_and_indent(stmt)
       table_str << ";"
-
-      table_columns = create_stmt.table_elts.map do |elt|
-        "\n    #{deparse_table_elt(elt)}"
-      end.join(",")
-      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: { 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)
-        )
-      )
-      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
+      table_str = "\n\n\n-- Name: #{stmt.view.relname}; Type: VIEW;\n\n"
+      table_str << deparse_stmt_and_indent(stmt)
+      table_str << ";"
+      table_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!(/ +$/, "")
+    def deparse_create_table_as_stmt(stmt)
+      table_str = "\n\n\n-- Name: #{stmt.into.rel.relname}; Type: MATERIALIZED VIEW;\n\n"
+      table_str << deparse_stmt_and_indent(stmt)
 
-      select_stmt_str
-    end
+      # couldn't find a better solution for this, but probably an OK workaround?
+      table_str.gsub!(/ WITH NO DATA\z/, "\nWITH NO DATA")
 
-    def deparse_res_target(res_target)
-      PgQuery.deparse_stmt(
-        PgQuery::SelectStmt.new(target_list: [PgQuery::Node.from(res_target)])
-      ).gsub(/\ASELECT /, "")
+      table_str << ";"
+      table_str
     end
 
-    def placeholder_query_string(placeholder_name = "placeholder")
-      PgQuery.deparse_stmt(placeholder_query_stmt(placeholder_name))
+    def deparse_stmt_and_indent(stmt)
+      Indenter.new(deparse_stmt(stmt)).indent
     end
 
-    def placeholder_query_stmt(placeholder_name = "placeholder")
-      PgQuery.parse("SELECT #{placeholder_name}").tree.stmts.first.stmt.select_stmt
+    def deparse_stmt(stmt)
+      PgQuery.deparse_stmt(stmt)
     end
   end
 end

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

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require "pg_query"
+
+module ActiveRecordPgFormatDbStructure
+  # Inserts newlines and whitespace on a deparsed SQL string
+  class Indenter
+    Token = Data.define(:type, :string)
+
+    # Reserved Keywords
+    ADD = :ADD_P
+    ALTER = :ALTER
+    AND = :AND
+    AS = :AS
+    CASE = :CASE
+    CREATE = :CREATE
+    CROSS = :CROSS
+    DROP = :DROP
+    ELSE = :ELSE
+    END_P = :END_P
+    EXCEPT = :EXCEPT
+    FETCH = :FETCH
+    FOR = :FOR
+    FROM = :FROM
+    GROUP = :GROUP_P
+    HAVING = :HAVING
+    INNER = :INNER
+    INSERT = :INSERT
+    INTERSECT = :INTERSECT
+    JOIN = :JOIN
+    LEFT = :LEFT
+    LIMIT = :LIMIT
+    OFFSET = :OFFSET
+    OR = :OR
+    ORDER = :ORDER
+    RIGHT = :RIGHT
+    SELECT = :SELECT
+    TABLE = :TABLE
+    THEN = :THEN
+    UNION = :UNION
+    VALUES = :VALUES
+    VIEW = :VIEW
+    WHEN = :WHEN
+    WHERE = :WHERE
+    WHITESPACE = :WHITESPACE
+    WINDOW = :WINDOW
+    WITH = :WITH
+
+    # ASCII tokens
+    COMMA = :ASCII_44
+    OPEN_PARENS = :ASCII_40
+    CLOSE_PARENS = :ASCII_41
+
+    # Helpers
+    PARENS = :PARENS
+    INDENT_STRING = "  "
+    SELECT_PADDING = "   "
+    TABLE_ELTS = :TABLE_ELTS
+
+    attr_reader :source
+
+    def initialize(source)
+      @source = PgQuery.deparse(PgQuery.parse(source).tree)
+    end
+
+    def indent
+      output = Output.new
+      prev_token = nil
+      tokens.each do |token|
+        output.current_token = token
+        case { current_token: token.type, prev_token: prev_token&.type, inside: output.current_scope_type }
+        in { current_token: CREATE, inside: nil }
+          output.append_scope(type: CREATE)
+          output.append_token
+        in { current_token: ALTER, inside: nil }
+          output.append_scope(type: ALTER, indent: 1)
+          output.append_token
+        in { current_token: INSERT, inside: nil }
+          output.append_scope(type: INSERT, indent: 0)
+          output.append_token
+        in { current_token: VIEW, inside: CREATE }
+          output.append_scope(type: VIEW, indent: 2)
+          output.append_token
+        in { current_token: WITH, inside: CREATE | VIEW | nil }
+          output.append_scope(type: WITH)
+          output.append_token
+        in { current_token: WHITESPACE, prev_token: AS, inside: VIEW }
+          output.append_token
+          output.newline
+          output.apply_indent
+        in { current_token: WHITESPACE, prev_token: COMMA, inside: WITH | SELECT | TABLE_ELTS }
+          output.append_token
+          output.newline
+          output.apply_indent
+        in { current_token: COMMA, inside: INSERT }
+          output.newline
+          output.apply_indent
+          output.append_token
+        in { current_token: SELECT, inside: WITH | INSERT }
+          output.pop_scope
+          output.newline
+          output.apply_indent
+          output.append_token
+          output.append_scope(type: SELECT, indent: 2, padding: SELECT_PADDING)
+        in { current_token: SELECT }
+          output.append_token
+          output.append_scope(type: SELECT, indent: 2, padding: SELECT_PADDING)
+        in { current_token: ALTER | ADD | DROP, inside: ALTER }
+          output.newline
+          output.apply_indent
+          output.append_token
+        in {
+          current_token: CROSS | INNER | LEFT | RIGHT | JOIN => type,
+          inside: SELECT | FROM | JOIN
+        }
+          output.pop_scope
+          output.newline
+          output.apply_indent
+          output.append_token
+          output.append_scope(type:, indent: 0)
+        in {
+          current_token: CROSS | INNER | LEFT | RIGHT | JOIN => type,
+          inside: CROSS | INNER | LEFT | RIGHT
+        }
+          output.append_token
+          output.pop_scope
+          output.append_scope(type:, indent: 0)
+        in {
+          current_token: FROM | WHERE | GROUP | ORDER | WINDOW | HAVING | LIMIT | OFFSET | FETCH | FOR | UNION |
+            INTERSECT | EXCEPT => token_type
+        }
+          output.pop_scope
+          output.newline
+          output.apply_indent
+          output.append_token
+          output.append_scope(type: token_type, indent: 1)
+        in { current_token: OR | AND, inside: WHERE }
+          output.newline
+          output.apply_indent
+          output.append_token(rjust: 3)
+        in { current_token: CASE }
+          output.append_token
+          output.append_scope(type: CASE, indent: 1, padding: output.current_padding)
+        in { current_token: WHEN | ELSE, inside: CASE }
+          output.newline
+          output.apply_indent
+          output.append_token
+        in { current_token: END_P }
+          output.pop_scope
+          output.newline
+          output.apply_indent
+          output.append_token
+        in { current_token: VALUES, inside: INSERT }
+          output.append_token
+          output.newline
+          output.append_whitespace
+        in { current_token: OPEN_PARENS, inside: CREATE }
+          output.append_token
+          output.newline
+          output.append_scope(type: TABLE_ELTS, indent: 2)
+          output.apply_indent
+        in { current_token: OPEN_PARENS, inside: WITH }
+          output.append_token
+          output.newline
+          output.append_scope(type: PARENS, indent: 2)
+          output.apply_indent
+        in { current_token: OPEN_PARENS, inside: JOIN }
+          output.append_token
+          output.newline
+          output.append_scope(type: PARENS, indent: 2)
+          output.apply_indent
+        in { current_token: OPEN_PARENS }
+          output.append_scope(type: PARENS)
+          output.append_token
+        in { current_token: CLOSE_PARENS, inside: TABLE_ELTS }
+          output.pop_scope
+          output.newline
+          output.apply_indent
+          output.append_token
+        in { current_token: CLOSE_PARENS, inside: PARENS }
+          output.pop_scope
+          output.append_token
+        in { current_token: CLOSE_PARENS }
+          loop do
+            break if output.pop_scope in PARENS | nil
+          end
+          output.newline
+          output.apply_indent
+          output.append_token
+        else
+          output.append_token
+        end
+        prev_token = token
+      end
+      output.to_s
+    end
+
+    private
+
+    def tokens
+      tmp_tokens = []
+      prev_token = Data.define(:end).new(0)
+      PgQuery.scan(source).first.tokens.each do |token|
+        if prev_token.end != token.start
+          tmp_tokens << Token.new(
+            type: WHITESPACE,
+            string: " "
+          )
+        end
+        prev_token = token
+        tmp_tokens << Token.new(
+          type: token.token,
+          string: source[token.start...token.end]
+        )
+      end
+      tmp_tokens
+    end
+
+    # Wrapper that ensures we only append whitespace, and always
+    # append the current token exactly once for each loop.
+    class Output
+      Scope = Data.define(:type, :indent, :padding)
+
+      def initialize
+        @string = +""
+        @scopes = [Scope.new(type: nil, indent: 0, padding: "")]
+        @current_token = nil
+      end
+
+      def to_s
+        # clean extra whitespace at end of string
+        @string.gsub(/\s+\n/, "\n").freeze
+      end
+
+      def current_scope_type
+        @scopes.last.type
+      end
+
+      def current_token=(token)
+        raise "Previous token was not appended!" unless @current_token.nil?
+
+        @current_token = token
+      end
+
+      def append_scope(type:, indent: 0, padding: "")
+        @scopes << Scope.new(type:, indent:, padding:)
+      end
+
+      def current_padding
+        @scopes.last.padding
+      end
+
+      def pop_scope
+        @scopes.pop.type
+      end
+
+      def newline
+        @string << "\n"
+      end
+
+      def append_whitespace
+        @string << " "
+      end
+
+      def apply_indent
+        @string << (INDENT_STRING * @scopes.sum(&:indent))
+        @string << @scopes.last.padding
+      end
+
+      def append_token(rjust: 0)
+        raise "Token was already appended!" if @current_token.nil?
+
+        @string << @current_token.string.rjust(rjust)
+        @current_token = nil
+      end
+    end
+  end
+end

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

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-pg-format-db-structure
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Jell
 bindir: exe
 cert_chain: []
-date: 2025-01-30 00:00:00.000000000 Z
+date: 2025-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_query
@@ -41,6 +41,7 @@ files:
 - lib/activerecord-pg-format-db-structure.rb
 - lib/activerecord-pg-format-db-structure/deparser.rb
 - lib/activerecord-pg-format-db-structure/formatter.rb
+- lib/activerecord-pg-format-db-structure/indenter.rb
 - 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