sql_beautifier 0.6.0 → 0.7.0

data/lib/sql_beautifier/configuration.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module SqlBeautifier
-  class Configuration
+  class Configuration < Base
     DEFAULTS = {
       keyword_case: :lower,
       keyword_column_width: 8,
@@ -14,20 +14,9 @@ module SqlBeautifier
       removable_comment_types: :none,
     }.freeze
 
-    COMMENT_TYPES = %i[inline separate_line blocks].freeze
-
-    attr_accessor :keyword_case
-    attr_accessor :keyword_column_width
-    attr_accessor :indent_spaces
-    attr_accessor :clause_spacing_mode
-    attr_accessor :table_name_format
-    attr_accessor :inline_group_threshold
-    attr_accessor :alias_strategy
-    attr_accessor :trailing_semicolon
-    attr_accessor :removable_comment_types
-
-    def initialize
-      reset!
+    DEFAULTS.each_key do |key|
+      option key, default: -> { DEFAULTS[key] }
+      attr_writer key
     end
 
     def reset!

data/lib/sql_beautifier/create_table_as.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class CreateTableAs < Base
+    MODIFIERS = %w[temp temporary unlogged local].freeze
+    WITH_DATA_SUFFIX_REGEX = %r{\s+(with\s+(?:no\s+)?data)\s*\z}i
+
+    option :modifier, default: -> {}
+    option :if_not_exists, type: Types::Bool
+    option :table_name
+    option :body_sql
+    option :suffix, default: -> {}
+    option :depth, default: -> { 0 }
+
+    def self.parse(normalized_sql, depth: 0)
+      scanner = Scanner.new(normalized_sql)
+      return nil unless scanner.keyword_at?("create")
+
+      scanner.skip_past_keyword!("create")
+      modifier = detect_modifier(scanner)
+      scanner.skip_past_keyword!(modifier) if modifier
+
+      return nil unless scanner.keyword_at?("table")
+
+      scanner.skip_past_keyword!("table")
+
+      if_not_exists = detect_if_not_exists?(scanner)
+      skip_past_if_not_exists!(scanner) if if_not_exists
+
+      table_name = scanner.read_identifier!
+      return nil unless table_name
+
+      scanner.skip_whitespace!
+      return nil unless scanner.keyword_at?("as")
+
+      scanner.skip_past_keyword!("as")
+
+      body_sql, suffix = extract_body(normalized_sql, scanner.position)
+      return nil unless body_sql
+
+      new(modifier: modifier, if_not_exists: if_not_exists, table_name: table_name, body_sql: body_sql, suffix: suffix, depth: depth)
+    end
+
+    def self.detect_modifier(scanner)
+      MODIFIERS.detect { |modifier| scanner.keyword_at?(modifier) }
+    end
+
+    def self.detect_if_not_exists?(scanner)
+      return false unless scanner.keyword_at?("if")
+
+      probe = Scanner.new(scanner.source, position: scanner.position)
+      probe.skip_past_keyword!("if")
+      return false unless probe.keyword_at?("not")
+
+      probe.skip_past_keyword!("not")
+      probe.keyword_at?("exists")
+    end
+
+    def self.skip_past_if_not_exists!(scanner)
+      scanner.skip_past_keyword!("if")
+      scanner.skip_past_keyword!("not")
+      scanner.skip_past_keyword!("exists")
+    end
+
+    def self.extract_body(sql, position)
+      scanner = Scanner.new(sql, position: position)
+      scanner.skip_whitespace!
+      return nil if scanner.finished?
+
+      if scanner.current_char == Constants::OPEN_PARENTHESIS
+        closing = scanner.find_matching_parenthesis(scanner.position)
+        return nil unless closing
+
+        body = sql[(scanner.position + 1)...closing].strip
+        suffix = sql[(closing + 1)..].strip.presence
+        [body, suffix]
+      else
+        extract_unparenthesized_body(sql[scanner.position..].strip)
+      end
+    end
+
+    def self.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 render
+      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 do |line|
+        line.strip.empty? ? "\n" : "#{indentation}#{line}"
+      end.join
+
+      formatted_suffix = @suffix ? " #{format_suffix}" : ""
+      "#{preamble} (\n#{indented_lines}\n)#{formatted_suffix}\n"
+    end
+
+    private
+
+    def preamble
+      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_suffix
+      @suffix.strip.split(Constants::WHITESPACE_REGEX).map { |word| Util.format_keyword(word) }.join(" ")
+    end
+  end
+end

data/lib/sql_beautifier/cte_definition.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class CteDefinition < Base
+    option :name
+    option :body_sql
+    option :column_list, default: -> {}
+    option :materialization, default: -> {}
+
+    def render_header
+      header = +@name.to_s
+      header << " (#{@column_list})" if @column_list
+      header << " #{Util.format_keyword('as')}"
+      header << " #{format_materialization}" if @materialization
+      header << " "
+      header
+    end
+
+    def render_body(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 do |line|
+        line.strip.empty? ? "\n" : "#{indentation}#{line}"
+      end.join
+
+      "(\n#{indented_lines}\n#{Util.whitespace(base_indent)})"
+    end
+
+    private
+
+    def format_materialization
+      return Util.format_keyword("materialized") if @materialization == "materialized"
+
+      [Util.format_keyword("not"), Util.format_keyword("materialized")].join(" ")
+    end
+  end
+end

data/lib/sql_beautifier/cte_query.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class CteQuery < Base
+    option :recursive, type: Types::Bool
+    option :definitions
+    option :main_query_sql
+    option :depth, default: -> { 0 }
+
+    def self.parse(normalized_sql, depth: 0)
+      scanner = Scanner.new(normalized_sql)
+      return nil unless scanner.keyword_at?("with")
+
+      scanner.skip_past_keyword!("with")
+
+      recursive = scanner.keyword_at?("recursive")
+      scanner.skip_past_keyword!("recursive") if recursive
+
+      definitions = []
+
+      loop do
+        definition, new_position = parse_raw_definition(normalized_sql, scanner.position)
+        break unless definition
+
+        definitions << CteDefinition.new(**definition)
+        scanner.advance!(new_position - scanner.position)
+        scanner.skip_whitespace!
+
+        break unless scanner.position < normalized_sql.length && scanner.current_char == Constants::COMMA
+
+        scanner.advance!
+        scanner.skip_whitespace!
+      end
+
+      main_query_sql = normalized_sql[scanner.position..].strip
+      return nil unless definitions.any? && main_query_sql.present?
+
+      new(recursive: recursive, definitions: definitions, main_query_sql: main_query_sql, depth: depth)
+    end
+
+    def self.parse_raw_definition(sql, position)
+      scanner = Scanner.new(sql, position: position)
+
+      name = scanner.read_identifier!
+      return nil unless name
+
+      scanner.skip_whitespace!
+
+      column_list = parse_column_list(sql, scanner.position)
+      scanner.advance!(column_list[:next_position] - scanner.position) if column_list
+
+      return nil unless scanner.keyword_at?("as")
+
+      scanner.skip_past_keyword!("as")
+      materialization, materialization_end_position = parse_materialization(sql, scanner.position)
+      scanner.advance!(materialization_end_position - scanner.position)
+
+      return nil unless scanner.position < sql.length && scanner.current_char == Constants::OPEN_PARENTHESIS
+
+      closing = scanner.find_matching_parenthesis(scanner.position)
+      return nil unless closing
+
+      body_sql = sql[(scanner.position + 1)...closing].strip
+      result = { name: name, body_sql: body_sql }
+      result[:column_list] = column_list[:text] if column_list
+      result[:materialization] = materialization if materialization
+
+      [result, closing + 1]
+    end
+
+    def self.parse_column_list(sql, position)
+      return nil unless position < sql.length && sql[position] == Constants::OPEN_PARENTHESIS
+
+      scanner = Scanner.new(sql)
+      closing = scanner.find_matching_parenthesis(position)
+      return nil unless closing
+
+      after_paren_scanner = Scanner.new(sql, position: closing + 1)
+      after_paren_scanner.skip_whitespace!
+      return nil unless after_paren_scanner.keyword_at?("as")
+
+      { text: sql[(position + 1)...closing].strip, next_position: after_paren_scanner.position }
+    end
+
+    def self.parse_materialization(sql, position)
+      scanner = Scanner.new(sql, position: position)
+      scanner.skip_whitespace!
+
+      if scanner.keyword_at?("materialized")
+        scanner.skip_past_keyword!("materialized")
+        return ["materialized", scanner.position]
+      end
+
+      return [nil, scanner.position] unless scanner.keyword_at?("not")
+
+      scanner.skip_past_keyword!("not")
+
+      return [nil, position] unless scanner.keyword_at?("materialized")
+
+      scanner.skip_past_keyword!("materialized")
+      ["not materialized", scanner.position]
+    end
+
+    def render
+      keyword_width = SqlBeautifier.config_for(:keyword_column_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.render_header
+        output << definition.render_body(keyword_width)
+        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
+  end
+end

data/lib/sql_beautifier/expression.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class Expression < Base
+    option :definition
+    option :alias_name, default: -> {}
+
+    def self.parse(text)
+      stripped = text.strip
+      alias_position = find_top_level_as(stripped)
+
+      if alias_position
+        definition = stripped[0...alias_position].strip
+        alias_name = stripped[(alias_position + 3)..].strip
+        new(definition: definition, alias_name: alias_name)
+      else
+        new(definition: stripped)
+      end
+    end
+
+    def self.find_top_level_as(text)
+      scanner = Scanner.new(text)
+
+      until scanner.finished?
+        consumed = scanner.scan_quoted_or_sentinel!
+        next if consumed
+
+        if scanner.current_char == Constants::OPEN_PARENTHESIS
+          scanner.increment_depth!
+          scanner.advance!
+          next
+        end
+
+        if scanner.current_char == Constants::CLOSE_PARENTHESIS
+          scanner.decrement_depth!
+          scanner.advance!
+          next
+        end
+
+        return scanner.position if scanner.top_level? && scanner.keyword_at?("as")
+
+        scanner.advance!
+      end
+
+      nil
+    end
+
+    def render
+      return @definition unless @alias_name
+
+      "#{@definition} as #{@alias_name}"
+    end
+  end
+end

data/lib/sql_beautifier/formatter.rb

@@ -2,8 +2,11 @@
 
 module SqlBeautifier
   class Formatter
-    def self.call(value)
-      new(value).call
+    LEADING_SENTINEL_PATTERN = %r{\A#{CommentParser::SENTINEL_PATTERN}[[:space:]]*}
+    LEADING_SENTINEL_CAPTURE = %r{\A(#{CommentParser::SENTINEL_PATTERN}[[:space:]]*)}
+
+    def self.call(...)
+      new(...).call
     end
 
     def initialize(value, depth: 0)
@@ -20,33 +23,20 @@ module SqlBeautifier
       @leading_sentinels = extract_leading_sentinels!
       return unless @normalized_value.present?
 
-      cte_result = CteFormatter.format(@normalized_value, depth: @depth)
+      cte_result = CteQuery.parse(@normalized_value, depth: @depth)&.render
       return prepend_sentinels(cte_result) if cte_result
 
-      create_table_as_result = CreateTableAsFormatter.format(@normalized_value, depth: @depth)
+      create_table_as_result = CreateTableAs.parse(@normalized_value, depth: @depth)&.render
       return prepend_sentinels(create_table_as_result) if create_table_as_result
 
       first_clause_position = Tokenizer.first_clause_position(@normalized_value)
       return prepend_sentinels("#{@normalized_value}\n") if first_clause_position.nil? || first_clause_position.positive?
 
-      @clauses = Tokenizer.split_into_clauses(@normalized_value)
-      @table_registry = TableRegistry.new(@clauses[:from]) if @clauses[:from].present?
-      @parts = []
-
-      append_clause!(:select, Clauses::Select)
-      append_from_clause!
-      append_clause!(:where, Clauses::Where)
-      append_clause!(:group_by, Clauses::GroupBy)
-      append_clause!(:having, Clauses::Having)
-      append_clause!(:order_by, Clauses::OrderBy)
-      append_clause!(:limit, Clauses::Limit)
+      query = Query.parse(@normalized_value, depth: @depth)
+      result = query.render
+      return prepend_sentinels("#{@normalized_value}\n") unless result
 
-      output = @parts.join(clause_separator)
-      return prepend_sentinels("#{@normalized_value}\n") if output.empty?
-
-      output = SubqueryFormatter.format(output, @depth)
-      output = @table_registry.apply_aliases(output) if @table_registry
-      prepend_sentinels("#{output}\n")
+      prepend_sentinels(result)
     end
 
     private
@@ -55,8 +45,8 @@ module SqlBeautifier
       leading_sentinel_text = +""
       remaining_value = @normalized_value
 
-      while remaining_value.match?(%r{\A#{CommentStripper::SENTINEL_PATTERN}[[:space:]]*})
-        match = remaining_value.match(%r{\A(#{CommentStripper::SENTINEL_PATTERN}[[:space:]]*)})
+      while remaining_value.match?(LEADING_SENTINEL_PATTERN)
+        match = remaining_value.match(LEADING_SENTINEL_CAPTURE)
         leading_sentinel_text << match[1]
         remaining_value = remaining_value[match[1].length..]
       end
@@ -71,62 +61,5 @@ module SqlBeautifier
 
       "#{@leading_sentinels}#{output}"
     end
-
-    def append_clause!(clause_key, formatter_class)
-      value = @clauses[clause_key]
-      return unless value.present?
-
-      @parts << formatter_class.call(value)
-    end
-
-    def append_from_clause!
-      value = @clauses[:from]
-      return unless value.present?
-
-      @parts << Clauses::From.call(value, table_registry: @table_registry)
-    end
-
-    def clause_separator
-      return "\n\n" if SqlBeautifier.config_for(:clause_spacing_mode) == :spacious
-      return "\n\n" unless compact_query?
-
-      "\n"
-    end
-
-    def compact_query?
-      compact_clause_set? && single_select_column? && single_from_table? && one_or_fewer_conditions?
-    end
-
-    def compact_clause_set?
-      clause_keys = @clauses.keys
-      allowed_keys = %i[select from where order_by limit]
-
-      clause_keys.all? { |key| allowed_keys.include?(key) } && clause_keys.include?(:select) && clause_keys.include?(:from)
-    end
-
-    def single_select_column?
-      select_value = @clauses[:select]
-      return false unless select_value.present?
-
-      formatted_select = Clauses::Select.call(select_value)
-      formatted_select.lines.length == 1
-    end
-
-    def single_from_table?
-      from_value = @clauses[:from]
-      return false unless from_value.present?
-
-      join_keywords = Constants::JOIN_KEYWORDS_BY_LENGTH.any? { |keyword| Tokenizer.find_top_level_keyword(from_value, keyword) }
-      return false if join_keywords
-
-      !from_value.match?(%r{,})
-    end
-
-    def one_or_fewer_conditions?
-      where_value = @clauses[:where]
-      return true unless where_value.present?
-
-      Tokenizer.split_top_level_conditions(where_value).length <= 1
-    end
   end
 end

data/lib/sql_beautifier/join.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class Join < Base
+    option :keyword
+    option :table_reference
+    option :trailing_sentinels, default: -> {}
+    option :conditions, default: -> { [] }
+
+    def self.parse(join_text, table_registry:)
+      keyword, remaining_content = extract_keyword(join_text)
+      return unless keyword && remaining_content
+
+      on_keyword_position = Tokenizer.find_top_level_keyword(remaining_content, "on")
+
+      if on_keyword_position
+        table_text = remaining_content[0...on_keyword_position].strip
+        condition_text = remaining_content[on_keyword_position..].delete_prefix("on").strip
+        conditions = Tokenizer.split_top_level_conditions(condition_text)
+      else
+        table_text = remaining_content
+        conditions = []
+      end
+
+      table_name = Util.first_word(table_text)
+      table_ref = table_registry.reference_for(table_name)
+      trailing_sentinels = extract_trailing_sentinels(table_text)
+
+      new(keyword: keyword, table_reference: table_ref, trailing_sentinels: trailing_sentinels, conditions: conditions)
+    end
+
+    def self.extract_keyword(join_text)
+      trimmed = join_text.strip
+
+      Constants::JOIN_KEYWORDS_BY_LENGTH.each do |keyword|
+        next unless trimmed.downcase.start_with?(keyword)
+
+        remaining = trimmed[keyword.length..].strip
+        return [keyword, remaining]
+      end
+
+      [nil, nil]
+    end
+
+    def self.extract_trailing_sentinels(text)
+      text.scan(CommentParser::SENTINEL_PATTERN).map do |match|
+        "#{CommentParser::SENTINEL_PREFIX}#{match[0]}#{CommentParser::SENTINEL_SUFFIX}"
+      end.presence
+    end
+
+    def render(continuation_indent:, condition_indent:)
+      rendered_table = @table_reference.render(trailing_sentinels: @trailing_sentinels)
+      lines = []
+
+      if @conditions.any?
+        first_condition = @conditions.first[1]
+        lines << "#{continuation_indent}#{@keyword} #{rendered_table} on #{first_condition}"
+
+        @conditions.drop(1).each do |conjunction, condition|
+          lines << "#{condition_indent}#{conjunction} #{condition}"
+        end
+      else
+        lines << "#{continuation_indent}#{@keyword} #{rendered_table}"
+      end
+
+      lines.join("\n")
+    end
+  end
+end