sql_beautifier 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6df1f55c9242793101e9f562329763541d56aa4f17f7e3d81a12038ab5b53cca
-  data.tar.gz: 43fea825ac0c4bded07098814a2ed67e5503e1829f3d47cc99a7c989ec0e69d1
+  metadata.gz: 928801124a1241f4b12dc2e7e7966cd95dcba5754cc6ee88a08c9f641f2e32e4
+  data.tar.gz: eb1db005fb6923f5f99aaacc44caeeed14b6c7f6e4d8cd174fb3fcff92cf944e
 SHA512:
-  metadata.gz: d56c72c27d4b71781be0ee83ba44fb3a4e466567c5edbde267c2cfbeb245c81e78bc52a309d27e7dae69a2a7e3cbf1bb3ce55926a266a6c914e822140b6650b7
-  data.tar.gz: 9e2e5118b5b12e52551300e2c0219c6cc42907fdb87fd56a8e6e80e193b212ae36ff87ee48d2a0135dc0140121d145c3f104622a0efbd0a3bbeffe10af378cea
+  metadata.gz: c0ee8ca9569e7409f989cce52070112bb61af2c064dec679a96e7f26bb74837b8f2ae207617f619280140548fb5cc8804a1996464265415efc96d0e0fafc7085
+  data.tar.gz: b1cff6570a5137fd7ff26fd11eed662d7002c9d242ca03ea303c0c1711f4a44f12dbdc3958ce3657b0988742abd351792476ab0fc7171ccafebe1c28a70be595

data/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## [X.X.X] - YYYY-MM-DD
 
+## [0.4.0] - 2026-03-27
+
 ## [0.3.0] - 2026-03-27
 
 - Add configuration system with `SqlBeautifier.configure` block and `SqlBeautifier.reset_configuration!`

data/lib/sql_beautifier/cte_formatter.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module CteFormatter
+    module_function
+
+    def format(normalized_sql, depth: 0)
+      return nil unless cte_query?(normalized_sql)
+
+      recursive, definitions, main_query_sql = parse(normalized_sql)
+      return nil unless definitions.any? && main_query_sql.present?
+
+      format_cte_statement(recursive, definitions, main_query_sql, depth)
+    end
+
+    def cte_query?(sql)
+      Tokenizer.keyword_at?(sql, 0, "with")
+    end
+
+    def parse(sql)
+      position = skip_past_keyword(sql, 0, "with")
+
+      recursive = Tokenizer.keyword_at?(sql, position, "recursive")
+      position = skip_past_keyword(sql, position, "recursive") if recursive
+
+      definitions = []
+
+      loop do
+        definition, new_position = parse_definition(sql, position)
+        break unless definition
+
+        definitions << definition
+        position = skip_whitespace(sql, new_position)
+
+        break unless position < sql.length && sql[position] == Constants::COMMA
+
+        position = skip_whitespace(sql, position + 1)
+      end
+
+      main_query_sql = sql[position..].strip
+
+      [recursive, definitions, main_query_sql]
+    end
+
+    def parse_definition(sql, position)
+      name, position = read_identifier(sql, position)
+      return nil unless name
+
+      position = skip_whitespace(sql, position)
+
+      column_list = parse_column_list(sql, position)
+      position = column_list[:next_position] if column_list
+
+      return nil unless Tokenizer.keyword_at?(sql, position, "as")
+
+      position = skip_past_keyword(sql, position, "as")
+      materialization, position = parse_materialization(sql, position)
+
+      return nil unless position < sql.length && sql[position] == Constants::OPEN_PARENTHESIS
+
+      closing = Tokenizer.find_matching_parenthesis(sql, position)
+      return nil unless closing
+
+      body_sql = sql[(position + 1)...closing].strip
+      definition = { name: name, body: body_sql }
+      definition[:column_list] = column_list[:text] if column_list
+      definition[:materialization] = materialization if materialization
+
+      [definition, closing + 1]
+    end
+
+    def parse_column_list(sql, position)
+      return nil unless position < sql.length && sql[position] == Constants::OPEN_PARENTHESIS
+
+      closing = Tokenizer.find_matching_parenthesis(sql, position)
+      return nil unless closing
+
+      after_paren = skip_whitespace(sql, closing + 1)
+      return nil unless Tokenizer.keyword_at?(sql, after_paren, "as")
+
+      { text: sql[(position + 1)...closing].strip, next_position: after_paren }
+    end
+
+    def format_cte_statement(recursive, definitions, main_query_sql, depth)
+      keyword_width = SqlBeautifier.config_for(:keyword_column_width)
+      cte_name_column = keyword_width
+      continuation_indent = Util.continuation_padding
+
+      output = +""
+
+      definitions.each_with_index do |definition, index|
+        if index.zero?
+          output << Util.keyword_padding("with")
+          output << "#{Util.format_keyword('recursive')} " if recursive
+        else
+          output << continuation_indent
+        end
+
+        output << definition_header(definition)
+        output << format_body(definition[:body], cte_name_column)
+        output << (index < definitions.length - 1 ? ",\n" : "\n\n")
+      end
+
+      formatted_main = Formatter.new(main_query_sql, depth: depth).call
+      output << formatted_main if formatted_main
+
+      output
+    end
+
+    def definition_header(definition)
+      header = +definition[:name].to_s
+      header << " (#{definition[:column_list]})" if definition[:column_list]
+      header << " #{Util.format_keyword('as')}"
+      header << " #{format_materialization(definition[:materialization])}" if definition[:materialization]
+      header << " "
+      header
+    end
+
+    def parse_materialization(sql, position)
+      position = skip_whitespace(sql, position)
+      return ["materialized", skip_past_keyword(sql, position, "materialized")] if Tokenizer.keyword_at?(sql, position, "materialized")
+      return [nil, position] unless Tokenizer.keyword_at?(sql, position, "not")
+
+      materialized_position = skip_past_keyword(sql, position, "not")
+      return [nil, position] unless Tokenizer.keyword_at?(sql, materialized_position, "materialized")
+
+      ["not materialized", skip_past_keyword(sql, materialized_position, "materialized")]
+    end
+
+    def format_materialization(materialization)
+      return Util.format_keyword("materialized") if materialization == "materialized"
+
+      [Util.format_keyword("not"), Util.format_keyword("materialized")].join(" ")
+    end
+
+    def format_body(body_sql, base_indent)
+      indent_spaces = SqlBeautifier.config_for(:indent_spaces) || 4
+      body_indent = base_indent + indent_spaces
+      formatted = Formatter.new(body_sql, depth: 0).call
+      return "(#{body_sql})" unless formatted
+
+      indentation = Util.whitespace(body_indent)
+      indented_lines = formatted.chomp.lines.map { |line| line.strip.empty? ? "\n" : "#{indentation}#{line}" }.join
+
+      "(\n#{indented_lines}\n#{Util.whitespace(base_indent)})"
+    end
+
+    def read_identifier(sql, position)
+      position = skip_whitespace(sql, position)
+      return nil if position >= sql.length
+
+      if sql[position] == Constants::DOUBLE_QUOTE
+        start = position
+        position += 1
+
+        while position < sql.length
+          if sql[position] == Constants::DOUBLE_QUOTE
+            if position + 1 < sql.length && sql[position + 1] == Constants::DOUBLE_QUOTE
+              position += 2
+              next
+            end
+
+            position += 1
+            break
+          end
+
+          position += 1
+        end
+
+        return nil unless position <= sql.length && sql[position - 1] == Constants::DOUBLE_QUOTE
+
+        return [sql[start...position], position]
+      end
+
+      start = position
+      position += 1 while position < sql.length && sql[position] =~ Tokenizer::IDENTIFIER_CHARACTER
+      return nil if position == start
+
+      [sql[start...position], position]
+    end
+
+    def skip_whitespace(sql, position)
+      position += 1 while position < sql.length && sql[position] =~ Constants::WHITESPACE_CHARACTER_REGEX
+      position
+    end
+
+    def skip_past_keyword(sql, position, keyword)
+      skip_whitespace(sql, position + keyword.length)
+    end
+  end
+end

data/lib/sql_beautifier/formatter.rb

@@ -17,6 +17,9 @@ module SqlBeautifier
       @normalized_value = Normalizer.call(@value)
       return unless @normalized_value.present?
 
+      cte_result = CteFormatter.format(@normalized_value, depth: @depth)
+      return cte_result if cte_result
+
       first_clause_position = Tokenizer.first_clause_position(@normalized_value)
       return "#{@normalized_value}\n" if first_clause_position.nil? || first_clause_position.positive?
 

data/lib/sql_beautifier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SqlBeautifier
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/sql_beautifier.rb

@@ -12,6 +12,7 @@ require_relative "sql_beautifier/tokenizer"
 require_relative "sql_beautifier/table_registry"
 require_relative "sql_beautifier/condition_formatter"
 require_relative "sql_beautifier/subquery_formatter"
+require_relative "sql_beautifier/cte_formatter"
 require_relative "sql_beautifier/clauses/base"
 require_relative "sql_beautifier/clauses/condition_clause"
 require_relative "sql_beautifier/clauses/select"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql_beautifier
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kinnell Shah
@@ -49,6 +49,7 @@ files:
 - lib/sql_beautifier/condition_formatter.rb
 - lib/sql_beautifier/configuration.rb
 - lib/sql_beautifier/constants.rb
+- lib/sql_beautifier/cte_formatter.rb
 - lib/sql_beautifier/formatter.rb
 - lib/sql_beautifier/normalizer.rb
 - lib/sql_beautifier/subquery_formatter.rb