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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f52ec941c9e147d32ce581a4e5384263455ca48295539f0d3a2b518cc7e4e51
-  data.tar.gz: 1ab211061fe2fca72d364dc8b92636e01c294ad4efddbd684a1a2b1b072d02a8
+  metadata.gz: 9eadcc90f7e5d8ec76f9f9494e7049646bf68ed37df502df31a1dc9fae87d2b6
+  data.tar.gz: bee026074f768393231546155fc52e0d00098cbdec981729a63c5a8d1efeb1c4
 SHA512:
-  metadata.gz: 87322b447a211cce08c5beebf137ca7a5da4947f0a01f37192978ea6a873d6f990201450ae3764501cccaa04667089b595bce39829d544e417ee7a9426d8ca5d
-  data.tar.gz: 27ebd693ed145add5112b35805c94e06b4f6f32e03419ffc92c62187116e3ec93d02694b0c67abf153e5a8582643989c2831e74b00f002b5758ba3fc7f6f7c5f
+  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,13 @@
 ## [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
+
 ## [0.1.1] - 2025-01-29
 
 - Proper deparsing of all statements

data/README.md

@@ -221,7 +221,7 @@ ALTER TABLE ONLY public.comments
 
 
 INSERT INTO schema_migrations (version) VALUES
- ('20250124155339')
+  ('20250124155339')
 ;
 ```
 
@@ -338,7 +338,7 @@ Should be run after other operations that inline alter statements.
 
 Returns an SQL string from raw PgQuery statements.
 
-Relying mostly on `PgQuery.deparse`, but applying some formatting using the [anbt-sql-formatter](https://github.com/sonota88/anbt-sql-formatter) gem on select & insert statements.
+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

@@ -1,187 +1,88 @@
 # frozen_string_literal: true
 
 require "pg_query"
-require "anbt-sql-formatter/formatter"
+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_query_statement(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)};"
+    def deparse_stmt_generic(stmt)
+      generic_str = +"\n\n"
+      generic_str << deparse_stmt_and_indent(stmt)
+      generic_str << ";"
+      generic_str
     end
 
-    def deparse_query_statement(stmt)
-      generic_query_str = +"\n\n"
-      generic_query_str << pretty_formt_sql_string(PgQuery.deparse_stmt(stmt))
-      generic_query_str << ";"
+    def deparse_stmt_compact(stmt)
+      compact_str = +"\n"
+      compact_str << deparse_stmt(stmt)
+      compact_str << ";"
+      compact_str
     end
 
-    def deparse_index_stmt(index_stmt)
-      deparse_stmt(index_stmt)
+    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_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
-    end
-
-    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: [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 << pretty_formt_sql_string(PgQuery.deparse_stmt(stmt.query.inner)).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 << pretty_formt_sql_string(PgQuery.deparse_stmt(stmt.query.inner)).gsub(/^/, PRETTY_INDENT_STRING)
-      query_str << "\n)"
-
-      view_stmt_str[placeholder_query_string] = query_str
-      view_stmt_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_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;"
+    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)
 
-      query_str = pretty_formt_sql_string(PgQuery.deparse_stmt(insert_stmt.select_stmt.inner))
-      query_str.gsub!(/\AVALUES /, "VALUES\n ")
+      # couldn't find a better solution for this, but probably an OK workaround?
+      table_str.gsub!(/ WITH NO DATA\z/, "\nWITH NO DATA")
 
-      insert_stmt_str[placeholder_query_string] = query_str
-      insert_stmt_str
-    end
-
-    def pretty_formt_sql_string(sql)
-      rule = AnbtSql::Rule.new
-      rule.keyword = AnbtSql::Rule::KEYWORD_UPPER_CASE
-      rule.indent_string = PRETTY_INDENT_STRING
-      formatter = AnbtSql::Formatter.new(rule)
-      formatter.format(sql)
+      table_str << ";"
+      table_str
     end
 
-    def placeholder_query_string
-      @placeholder_query_string ||= PgQuery.deparse_stmt(placeholder_query_stmt)
+    def deparse_stmt_and_indent(stmt)
+      Indenter.new(deparse_stmt(stmt)).indent
     end
 
-    def placeholder_query_stmt
-      @placeholder_query_stmt ||= PgQuery.parse("SELECT placeholder").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.1"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,28 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-pg-format-db-structure
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Jell
 bindir: exe
 cert_chain: []
-date: 2025-01-29 00:00:00.000000000 Z
+date: 2025-02-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: anbt-sql-formatter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: pg_query
   requirement: !ruby/object:Gem::Requirement
@@ -55,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