sql_beautifier 0.1.4 → 0.3.0

data/lib/sql_beautifier/condition_formatter.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module ConditionFormatter
+    module_function
+
+    def format(text, indent_width:)
+      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/configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class Configuration
+    DEFAULTS = {
+      keyword_case: :lower,
+      keyword_column_width: 8,
+      indent_spaces: 4,
+      clause_spacing_mode: :compact,
+      table_name_format: :pascal_case,
+      inline_group_threshold: 100,
+      alias_strategy: :initials,
+    }.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
+
+    def initialize
+      reset!
+    end
+
+    def reset!
+      DEFAULTS.each do |key, value|
+        public_send(:"#{key}=", value)
+      end
+    end
+  end
+end

data/lib/sql_beautifier/constants.rb

@@ -11,5 +11,32 @@ module SqlBeautifier
       "order by",
       "limit",
     ].freeze
+
+    JOIN_KEYWORDS = [
+      "inner join",
+      "left outer join",
+      "right outer join",
+      "full outer join",
+      "left join",
+      "right join",
+      "full join",
+      "cross join",
+    ].freeze
+
+    JOIN_KEYWORDS_BY_LENGTH = JOIN_KEYWORDS.sort_by { |keyword| -keyword.length }.freeze
+    JOIN_KEYWORD_PATTERN = %r{\b(#{JOIN_KEYWORDS.map { |keyword| Regexp.escape(keyword) }.join('|')})\b}i
+
+    CONJUNCTIONS = %w[and or].freeze
+    BETWEEN_KEYWORD = "between"
+
+    OPEN_PARENTHESIS = "("
+    CLOSE_PARENTHESIS = ")"
+    COMMA = ","
+
+    WHITESPACE_REGEX = %r{\s+}
+    WHITESPACE_CHARACTER_REGEX = %r{\s}
+    SINGLE_QUOTE = "'"
+    DOUBLE_QUOTE = '"'
+    ESCAPED_DOUBLE_QUOTE = '""'
   end
 end

data/lib/sql_beautifier/formatter.rb

@@ -6,8 +6,9 @@ module SqlBeautifier
       new(value).call
     end
 
-    def initialize(value)
+    def initialize(value, depth: 0)
       @value = value
+      @depth = depth
     end
 
     def call
@@ -20,19 +21,22 @@ module SqlBeautifier
       return "#{@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_clause!(:from, Clauses::From)
+      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)
 
-      output = @parts.join("\n\n")
+      output = @parts.join(clause_separator)
       return "#{@normalized_value}\n" if output.empty?
 
+      output = SubqueryFormatter.format(output, @depth)
+      output = @table_registry.apply_aliases(output) if @table_registry
       "#{output}\n"
     end
 
@@ -44,5 +48,55 @@ module SqlBeautifier
 
       @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/normalizer.rb

@@ -18,18 +18,23 @@ module SqlBeautifier
       @source = @value.strip
       return unless @source.present?
 
+      @source = strip_comments(@source)
+      @source = strip_trailing_semicolons(@source)
+      @source = @source.strip
+      return unless @source.present?
+
       @output = +""
       @position = 0
 
       while @position < @source.length
         case current_character
-        when "'"
+        when Constants::SINGLE_QUOTE
           consume_string_literal!
 
-        when '"'
+        when Constants::DOUBLE_QUOTE
           consume_quoted_identifier!
 
-        when %r{\s}
+        when Constants::WHITESPACE_CHARACTER_REGEX
           collapse_whitespace!
 
         else
@@ -50,7 +55,7 @@ module SqlBeautifier
     def collapse_whitespace!
       @output << " "
       @position += 1
-      @position += 1 while @position < @source.length && @source[@position] =~ %r{\s}
+      @position += 1 while @position < @source.length && @source[@position] =~ Constants::WHITESPACE_CHARACTER_REGEX
     end
 
     def consume_string_literal!
@@ -61,10 +66,10 @@ module SqlBeautifier
         character = current_character
         @output << character
 
-        if character == "'" && @source[@position + 1] == "'"
+        if character == Constants::SINGLE_QUOTE && @source[@position + 1] == Constants::SINGLE_QUOTE
           @position += 1
           @output << current_character
-        elsif character == "'"
+        elsif character == Constants::SINGLE_QUOTE
           @position += 1
           return
         end
@@ -81,10 +86,10 @@ module SqlBeautifier
       while @position < @source.length
         character = current_character
 
-        if character == '"' && @source[@position + 1] == '"'
-          identifier << '"'
+        if character == Constants::DOUBLE_QUOTE && @source[@position + 1] == Constants::DOUBLE_QUOTE
+          identifier << Constants::DOUBLE_QUOTE
           @position += 2
-        elsif character == '"'
+        elsif character == Constants::DOUBLE_QUOTE
           @position += 1
           @output << format_identifier(identifier)
           return
@@ -100,17 +105,81 @@ module SqlBeautifier
     end
 
     def format_identifier(identifier)
-      lowercased = identifier.downcase
+      downcased_identifier = identifier.downcase
+      return downcased_identifier unless requires_quoting?(downcased_identifier)
 
-      if requires_quoting?(lowercased)
-        "\"#{lowercased.gsub('"', '""')}\""
-      else
-        lowercased
-      end
+      escaped_identifier = Util.escape_double_quote(downcased_identifier)
+      Util.double_quote_string(escaped_identifier)
     end
 
     def requires_quoting?(identifier)
       identifier !~ SAFE_UNQUOTED_IDENTIFIER
     end
+
+    def strip_trailing_semicolons(sql)
+      sql.sub(%r{;[[:space:]]*\z}, "")
+    end
+
+    def strip_comments(sql)
+      output = +""
+      position = 0
+      in_single_quoted_string = false
+      in_double_quoted_identifier = false
+
+      while position < sql.length
+        character = sql[position]
+
+        if in_single_quoted_string
+          output << character
+
+          if character == Constants::SINGLE_QUOTE && sql[position + 1] == Constants::SINGLE_QUOTE
+            position += 1
+            output << sql[position]
+          elsif character == Constants::SINGLE_QUOTE
+            in_single_quoted_string = false
+          end
+
+          position += 1
+          next
+        end
+
+        if in_double_quoted_identifier
+          output << character
+
+          if character == Constants::DOUBLE_QUOTE && sql[position + 1] == Constants::DOUBLE_QUOTE
+            position += 1
+            output << sql[position]
+          elsif character == Constants::DOUBLE_QUOTE
+            in_double_quoted_identifier = false
+          end
+
+          position += 1
+          next
+        end
+
+        if character == Constants::SINGLE_QUOTE
+          in_single_quoted_string = true
+          output << character
+          position += 1
+        elsif character == Constants::DOUBLE_QUOTE
+          in_double_quoted_identifier = true
+          output << character
+          position += 1
+        elsif character == "-" && sql[position + 1] == "-"
+          position += 2
+          position += 1 while position < sql.length && sql[position] != "\n"
+        elsif character == "/" && sql[position + 1] == "*"
+          output << " " unless output.empty? || output[-1] =~ Constants::WHITESPACE_CHARACTER_REGEX
+          position += 2
+          position += 1 while position < sql.length && !(sql[position] == "*" && sql[position + 1] == "/")
+          position += 2 if position < sql.length
+        else
+          output << character
+          position += 1
+        end
+      end
+
+      output
+    end
   end
 end

data/lib/sql_beautifier/subquery_formatter.rb

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