sql_beautifier 0.6.0 → 0.7.0

data/lib/sql_beautifier/condition_formatter.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module SqlBeautifier
-  module ConditionFormatter
-    module_function
-
-    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))
-
-      conditions = flatten_same_conjunction_groups(conditions)
-      indentation = Util.whitespace(indent_width)
-      lines = []
-
-      conditions.each_with_index do |(conjunction, condition_text), index|
-        unwrapped_condition = unwrap_single_condition(condition_text)
-        formatted_condition_text = format_single_condition(unwrapped_condition, indent_width: indent_width)
-
-        line = begin
-          if index.zero?
-            "#{indentation}#{formatted_condition_text}"
-          else
-            "#{indentation}#{conjunction} #{formatted_condition_text}"
-          end
-        end
-
-        lines << line
-      end
-
-      lines.join("\n")
-    end
-
-    def flatten_same_conjunction_groups(conditions)
-      return conditions if conditions.length <= 1
-
-      outer_conjunction = conditions[1]&.first
-      return conditions unless outer_conjunction
-      return conditions unless conditions.drop(1).all? { |pair| pair[0] == outer_conjunction }
-
-      flattened_conditions = []
-
-      conditions.each do |conjunction, condition_text|
-        inner_conditions = parse_condition_group(condition_text)
-
-        if inner_conditions && flattenable_into_conjunction?(inner_conditions, outer_conjunction)
-          flatten_inner_conditions_into!(flattened_conditions, inner_conditions, conjunction, outer_conjunction)
-        else
-          flattened_conditions << [conjunction, condition_text]
-        end
-      end
-
-      flattened_conditions
-    end
-
-    def rebuild_inline(inner_conditions)
-      parts = inner_conditions.map.with_index do |(conjunction, condition_text), index|
-        index.zero? ? condition_text : "#{conjunction} #{condition_text}"
-      end
-
-      "(#{parts.join(' ')})"
-    end
-
-    def unwrap_single_condition(condition)
-      output = condition.strip
-
-      while Tokenizer.outer_parentheses_wrap_all?(output)
-        inner_content = Util.strip_outer_parentheses(output)
-        inner_conditions = Tokenizer.split_top_level_conditions(inner_content)
-        break if inner_conditions.length > 1
-
-        output = inner_content
-      end
-
-      output
-    end
-
-    def parse_condition_group(condition_text)
-      return unless condition_text
-
-      trimmed_condition = condition_text.strip
-      return unless Tokenizer.outer_parentheses_wrap_all?(trimmed_condition)
-
-      inner_content = Util.strip_outer_parentheses(trimmed_condition)
-      inner_conditions = Tokenizer.split_top_level_conditions(inner_content)
-      return unless inner_conditions.length > 1
-
-      inner_conditions
-    end
-
-    def format_single_condition(condition_text, indent_width:)
-      inner_conditions = parse_condition_group(condition_text)
-      return condition_text unless inner_conditions
-
-      inline_version = rebuild_inline(inner_conditions)
-      return inline_version if inline_version.length <= SqlBeautifier.config_for(:inline_group_threshold)
-
-      inner_content = Util.strip_outer_parentheses(condition_text.strip)
-      formatted_inner_content = format(inner_content, indent_width: indent_width + 4)
-      indentation = Util.whitespace(indent_width)
-
-      "(\n#{formatted_inner_content}\n#{indentation})"
-    end
-
-    def flattenable_into_conjunction?(inner_conditions, outer_conjunction)
-      inner_conjunction = inner_conditions[1]&.first
-
-      inner_conjunction == outer_conjunction && inner_conditions.drop(1).all? { |pair| pair[0] == outer_conjunction }
-    end
-
-    def flatten_inner_conditions_into!(flattened_conditions, inner_conditions, conjunction, outer_conjunction)
-      inner_conditions.each_with_index do |inner_pair, inner_index|
-        condition_pair = begin
-          if flattened_conditions.empty?
-            [nil, inner_pair[1]]
-          elsif inner_index.zero?
-            [conjunction || outer_conjunction, inner_pair[1]]
-          else
-            [outer_conjunction, inner_pair[1]]
-          end
-        end
-
-        flattened_conditions << condition_pair
-      end
-    end
-  end
-end

data/lib/sql_beautifier/create_table_as_formatter.rb

@@ -1,177 +0,0 @@
-# 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

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-module SqlBeautifier
-  module CteFormatter
-    module_function
-
-    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)
-      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/subquery_formatter.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module SqlBeautifier
-  module SubqueryFormatter
-    module_function
-
-    def format(text, base_indent)
-      output = +""
-      position = 0
-
-      while position < text.length
-        subquery_position = find_top_level_subquery(text, position)
-
-        unless subquery_position
-          output << text[position..]
-          break
-        end
-
-        output << text[position...subquery_position]
-
-        closing_position = Tokenizer.find_matching_parenthesis(text, subquery_position)
-
-        unless closing_position
-          output << text[subquery_position..]
-          break
-        end
-
-        inner_sql = text[(subquery_position + 1)...closing_position].strip
-        subquery_base_indent = subquery_base_indent_for(text, subquery_position, base_indent)
-        output << format_subquery(inner_sql, subquery_base_indent)
-        position = closing_position + 1
-      end
-
-      output
-    end
-
-    def find_top_level_subquery(text, start_position)
-      position = start_position
-      in_single_quoted_string = false
-      in_double_quoted_identifier = false
-      while position < text.length
-        character = text[position]
-
-        if in_single_quoted_string
-          if character == Constants::SINGLE_QUOTE && text[position + 1] == Constants::SINGLE_QUOTE
-            position += 2
-          elsif character == Constants::SINGLE_QUOTE
-            in_single_quoted_string = false
-            position += 1
-          else
-            position += 1
-          end
-          next
-        end
-
-        if in_double_quoted_identifier
-          if character == Constants::DOUBLE_QUOTE && text[position + 1] == Constants::DOUBLE_QUOTE
-            position += 2
-          elsif character == Constants::DOUBLE_QUOTE
-            in_double_quoted_identifier = false
-            position += 1
-          else
-            position += 1
-          end
-          next
-        end
-
-        case character
-        when Constants::SINGLE_QUOTE
-          in_single_quoted_string = true
-        when Constants::DOUBLE_QUOTE
-          in_double_quoted_identifier = true
-        when Constants::OPEN_PARENTHESIS
-          return position if select_follows?(text, position)
-        end
-
-        position += 1
-      end
-
-      nil
-    end
-
-    def format_subquery(inner_sql, base_indent)
-      indent_spaces = SqlBeautifier.config_for(:indent_spaces) || 4
-      subquery_indent = base_indent + indent_spaces
-      formatted = Formatter.new(inner_sql, depth: subquery_indent).call
-      return "(#{inner_sql})" unless formatted
-
-      indentation = Util.whitespace(subquery_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 subquery_base_indent_for(text, subquery_position, default_base_indent)
-      line_start_position = text.rindex("\n", subquery_position - 1)
-      line_start_position = line_start_position ? line_start_position + 1 : 0
-      line_before_subquery = text[line_start_position...subquery_position]
-      line_leading_spaces = line_before_subquery[%r{\A[[:space:]]*}].to_s.length
-
-      return default_base_indent unless line_before_subquery.lstrip.match?(%r{\Awhere(?:[[:space:]]|$)}i)
-
-      default_base_indent + line_leading_spaces + SqlBeautifier.config_for(:keyword_column_width)
-    end
-
-    def select_follows?(text, position)
-      remaining_text = text[(position + 1)..]
-      return false unless remaining_text
-
-      remaining_text.match?(%r{\A[[:space:]]*select(?:[[:space:]]|\()}i)
-    end
-  end
-end