sql_beautifier 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 928801124a1241f4b12dc2e7e7966cd95dcba5754cc6ee88a08c9f641f2e32e4
-  data.tar.gz: eb1db005fb6923f5f99aaacc44caeeed14b6c7f6e4d8cd174fb3fcff92cf944e
+  metadata.gz: 74ce2777ba2e1a7635aa92623cbb6e252bef41abafa62fff7b3f9f651aad05af
+  data.tar.gz: 83f543391d4e60f2ab928eb44c6975d4f935b84c7e63bcbb05685331bcdf59a2
 SHA512:
-  metadata.gz: c0ee8ca9569e7409f989cce52070112bb61af2c064dec679a96e7f26bb74837b8f2ae207617f619280140548fb5cc8804a1996464265415efc96d0e0fafc7085
-  data.tar.gz: b1cff6570a5137fd7ff26fd11eed662d7002c9d242ca03ea303c0c1711f4a44f12dbdc3958ce3657b0988742abd351792476ab0fc7171ccafebe1c28a70be595
+  metadata.gz: 3bbfe00044b32a468fb019a9d32010ce355803000d627d6b16146398b54515531d0a6b76a84022facaec39b1afb849307b08ee96b8859b00ad99f7f2895b2668
+  data.tar.gz: 2252b3c944667589b17c0bde79e2eca176ced558c6bf8d19795607490788dc468200a00a2dedbce667adee966956389b3957f70cc39fa317d865435ceee22007

data/CHANGELOG.md

@@ -2,8 +2,14 @@
 
 ## [X.X.X] - YYYY-MM-DD
 
+## [0.5.0] - 2026-03-28
+
+- Add support for Create Table As (CTA) formatting
+
 ## [0.4.0] - 2026-03-27
 
+- Add CTE (Common Table Expression) formatting with recursive indentation
+
 ## [0.3.0] - 2026-03-27
 
 - Add configuration system with `SqlBeautifier.configure` block and `SqlBeautifier.reset_configuration!`

data/lib/sql_beautifier/condition_formatter.rb

@@ -4,7 +4,8 @@ module SqlBeautifier
   module ConditionFormatter
     module_function
 
-    def format(text, indent_width:)
+    def format(text, args = {})
+      indent_width = args.fetch(:indent_width, 0)
       conditions = Tokenizer.split_top_level_conditions(text)
       return text.strip if conditions.length <= 1 && !parse_condition_group(conditions.dig(0, 1))
 

data/lib/sql_beautifier/create_table_as_formatter.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module CreateTableAsFormatter
+    MODIFIERS = %w[
+      temp
+      temporary
+      unlogged
+      local
+    ].freeze
+
+    WITH_DATA_SUFFIX_REGEX = %r{\s+(with\s+(?:no\s+)?data)\s*\z}i
+
+    module_function
+
+    def format(normalized_sql, _args = {})
+      return nil unless create_table_as_query?(normalized_sql)
+
+      parsed = parse(normalized_sql)
+      return nil unless parsed
+
+      format_statement(parsed[:preamble], parsed[:body], parsed[:suffix])
+    end
+
+    def create_table_as_query?(sql)
+      Tokenizer.keyword_at?(sql, 0, "create")
+    end
+
+    def parse(sql)
+      position = 0
+      return nil unless Tokenizer.keyword_at?(sql, position, "create")
+
+      position = skip_past_keyword(sql, position, "create")
+
+      modifier = detect_modifier(sql, position)
+      position = skip_past_keyword(sql, position, modifier) if modifier
+
+      return nil unless Tokenizer.keyword_at?(sql, position, "table")
+
+      position = skip_past_keyword(sql, position, "table")
+
+      if_not_exists = detect_if_not_exists?(sql, position)
+      position = skip_past_if_not_exists(sql, position) if if_not_exists
+
+      table_name, position = read_identifier(sql, position)
+      return nil unless table_name
+
+      position = skip_whitespace(sql, position)
+      return nil unless Tokenizer.keyword_at?(sql, position, "as")
+
+      position = skip_past_keyword(sql, position, "as")
+
+      result = extract_body(sql, position)
+      return nil unless result
+
+      body_sql, suffix = result
+      return nil unless body_sql
+
+      preamble = build_preamble(modifier, if_not_exists, table_name)
+      { preamble: preamble, body: body_sql, suffix: suffix }
+    end
+
+    def detect_modifier(sql, position)
+      MODIFIERS.detect { |modifier| Tokenizer.keyword_at?(sql, position, modifier) }
+    end
+
+    def detect_if_not_exists?(sql, position)
+      Tokenizer.keyword_at?(sql, position, "if") && Tokenizer.keyword_at?(sql, skip_past_keyword(sql, position, "if"), "not") && Tokenizer.keyword_at?(sql, skip_past_keyword(sql, skip_past_keyword(sql, position, "if"), "not"), "exists")
+    end
+
+    def skip_past_if_not_exists(sql, position)
+      position = skip_past_keyword(sql, position, "if")
+      position = skip_past_keyword(sql, position, "not")
+      skip_past_keyword(sql, position, "exists")
+    end
+
+    def extract_body(sql, position)
+      position = skip_whitespace(sql, position)
+      return nil if position >= sql.length
+
+      if sql[position] == Constants::OPEN_PARENTHESIS
+        closing = Tokenizer.find_matching_parenthesis(sql, position)
+        return nil unless closing
+
+        body = sql[(position + 1)...closing].strip
+        suffix = sql[(closing + 1)..].strip.presence
+        [body, suffix]
+      else
+        extract_unparenthesized_body(sql[position..].strip)
+      end
+    end
+
+    def extract_unparenthesized_body(raw_body)
+      return nil unless raw_body.present?
+
+      match = raw_body.match(WITH_DATA_SUFFIX_REGEX)
+
+      if match
+        body = raw_body[0...match.begin(0)].strip
+        return nil unless body.present?
+
+        [body, match[1]]
+      else
+        [raw_body, nil]
+      end
+    end
+
+    def build_preamble(modifier, if_not_exists, table_name)
+      parts = [Util.format_keyword("create")]
+      parts << Util.format_keyword(modifier) if modifier
+      parts << Util.format_keyword("table")
+      parts << "#{Util.format_keyword('if')} #{Util.format_keyword('not')} #{Util.format_keyword('exists')}" if if_not_exists
+      parts << Util.format_table_name(table_name)
+      parts << Util.format_keyword("as")
+      parts.join(" ")
+    end
+
+    def format_statement(preamble, body_sql, suffix)
+      indent_spaces = SqlBeautifier.config_for(:indent_spaces) || 4
+      formatted = Formatter.new(body_sql, depth: 0).call
+      return "#{preamble}\n" unless formatted
+
+      indentation = Util.whitespace(indent_spaces)
+      indented_lines = formatted.chomp.lines.map { |line| line.strip.empty? ? "\n" : "#{indentation}#{line}" }.join
+
+      formatted_suffix = suffix ? " #{format_suffix(suffix)}" : ""
+      "#{preamble} (\n#{indented_lines}\n)#{formatted_suffix}\n"
+    end
+
+    def format_suffix(suffix)
+      suffix.strip.split(%r{\s+}).map { |word| Util.format_keyword(word) }.join(" ")
+    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/cte_formatter.rb

@@ -4,7 +4,8 @@ module SqlBeautifier
   module CteFormatter
     module_function
 
-    def format(normalized_sql, depth: 0)
+    def format(normalized_sql, args = {})
+      depth = args.fetch(:depth, 0)
       return nil unless cte_query?(normalized_sql)
 
       recursive, definitions, main_query_sql = parse(normalized_sql)

data/lib/sql_beautifier/formatter.rb

@@ -20,6 +20,9 @@ module SqlBeautifier
       cte_result = CteFormatter.format(@normalized_value, depth: @depth)
       return cte_result if cte_result
 
+      create_table_as_result = CreateTableAsFormatter.format(@normalized_value, depth: @depth)
+      return create_table_as_result if create_table_as_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.4.0"
+  VERSION = "0.5.0"
 end

data/lib/sql_beautifier.rb

@@ -13,6 +13,7 @@ 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/create_table_as_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.4.0
+  version: 0.5.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/create_table_as_formatter.rb
 - lib/sql_beautifier/cte_formatter.rb
 - lib/sql_beautifier/formatter.rb
 - lib/sql_beautifier/normalizer.rb