sql_beautifier 0.1.4 → 0.3.0

data/lib/sql_beautifier/table_registry.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  class TableRegistry
+    attr_reader :table_map
+
+    def initialize(from_content)
+      @from_content = from_content
+      @table_map = {}
+      @alias_strategy = SqlBeautifier.config_for(:alias_strategy)
+      build!
+    end
+
+    def alias_for(table_name)
+      @table_map[table_name]
+    end
+
+    def apply_aliases(text)
+      return text if @table_map.empty?
+
+      output = +""
+      position = 0
+
+      while position < text.length
+        character = text[position]
+
+        case character
+        when Constants::SINGLE_QUOTE
+          position = copy_string_literal!(text, position, output)
+        when Constants::DOUBLE_QUOTE
+          position = copy_quoted_identifier!(text, position, output)
+        else
+          replacement = find_table_replacement_at(text, position)
+
+          if replacement
+            table_name, table_alias = replacement
+
+            output << "#{table_alias}."
+            position += table_name.length + 1
+          else
+            output << character
+            position += 1
+          end
+        end
+      end
+
+      output
+    end
+
+    private
+
+    def build!
+      table_entries = extract_table_entries(@from_content)
+
+      if @alias_strategy == :none
+        table_entries.each do |table_entry|
+          next unless table_entry[:explicit_alias]
+
+          @table_map[table_entry[:table_name]] = table_entry[:explicit_alias]
+        end
+      else
+        initials_occurrence_counts = count_initials_occurrences(table_entries)
+        used_aliases = []
+        assign_aliases!(table_entries, initials_occurrence_counts, used_aliases)
+      end
+
+      @tables_by_descending_length = @table_map.keys.sort_by { |name| -name.length }.freeze
+    end
+
+    def count_initials_occurrences(table_entries)
+      occurrence_counts = Hash.new(0)
+
+      table_entries.each do |table_entry|
+        next if table_entry[:explicit_alias]
+
+        table_name = table_entry[:table_name]
+        occurrence_counts[table_initials(table_name)] += 1
+      end
+
+      occurrence_counts
+    end
+
+    def assign_aliases!(table_entries, initials_occurrence_counts, used_aliases)
+      duplicate_initials_counts = Hash.new(0)
+      collision_counts = Hash.new(0)
+
+      table_entries.each do |table_entry|
+        table_name = table_entry[:table_name]
+        explicit_alias = table_entry[:explicit_alias]
+
+        if explicit_alias
+          @table_map[table_name] = explicit_alias
+          used_aliases << explicit_alias
+          next
+        end
+
+        initials = table_initials(table_name)
+        duplicate_initials_counts[initials] += 1 if initials_occurrence_counts[initials] > 1
+
+        candidate_alias = begin
+          if initials_occurrence_counts[initials] > 1
+            "#{initials}#{duplicate_initials_counts[initials]}"
+          else
+            initials
+          end
+        end
+
+        if used_aliases.include?(candidate_alias)
+          collision_counts[initials] = [collision_counts[initials], duplicate_initials_counts[initials]].max
+
+          loop do
+            collision_counts[initials] += 1
+            candidate_alias = "#{initials}#{collision_counts[initials]}"
+            break unless used_aliases.include?(candidate_alias)
+          end
+        end
+
+        @table_map[table_name] = candidate_alias
+        used_aliases << candidate_alias
+      end
+    end
+
+    def copy_string_literal!(text, position, output)
+      output << text[position]
+      position += 1
+
+      while position < text.length
+        character = text[position]
+        output << character
+
+        if Tokenizer.escaped_single_quote?(text, position)
+          position += 1
+          output << text[position]
+        elsif character == Constants::SINGLE_QUOTE
+          return position + 1
+        end
+
+        position += 1
+      end
+
+      position
+    end
+
+    def copy_quoted_identifier!(text, position, output)
+      output << text[position]
+      position += 1
+
+      while position < text.length
+        character = text[position]
+        output << character
+
+        if Tokenizer.escaped_double_quote?(text, position)
+          position += 1
+          output << text[position]
+        elsif character == Constants::DOUBLE_QUOTE
+          return position + 1
+        end
+
+        position += 1
+      end
+
+      position
+    end
+
+    def find_table_replacement_at(text, position)
+      return unless Tokenizer.word_boundary?(Tokenizer.character_before(text, position))
+
+      @tables_by_descending_length.each do |table_name|
+        next unless text[position, table_name.length + 1] == "#{table_name}."
+
+        return [table_name, @table_map[table_name]]
+      end
+
+      nil
+    end
+
+    def table_initials(table_name)
+      return @alias_strategy.call(table_name) if @alias_strategy.respond_to?(:call)
+
+      table_name.split("_").map { |segment| segment[0] }.join
+    end
+
+    def extract_table_entries(from_content)
+      split_segments = from_content.strip.split(Constants::JOIN_KEYWORD_PATTERN)
+
+      table_entries = []
+
+      primary_segment = split_segments.shift.strip
+      table_entries << extract_table_entry(primary_segment)
+
+      split_segments.each_slice(2) do |_join_keyword, join_content|
+        next unless join_content
+
+        table_entries << extract_table_entry(join_content)
+      end
+
+      table_entries.compact
+    end
+
+    def extract_table_entry(segment_text)
+      table_specification = table_specification_text(segment_text)
+      table_name = Util.first_word(table_specification)
+      return unless table_name
+
+      {
+        table_name: table_name,
+        explicit_alias: extract_explicit_alias(table_specification),
+      }
+    end
+
+    def table_specification_text(segment_text)
+      on_keyword_position = Tokenizer.find_top_level_keyword(segment_text, "on")
+      return segment_text.strip unless on_keyword_position
+
+      segment_text[0...on_keyword_position].strip
+    end
+
+    def extract_explicit_alias(table_specification)
+      words = table_specification.strip.split(Constants::WHITESPACE_REGEX)
+      return nil if words.length < 2
+
+      if words[1] == "as"
+        words[2]
+      else
+        words[1]
+      end
+    end
+  end
+end

data/lib/sql_beautifier/tokenizer.rb

@@ -16,8 +16,8 @@ module SqlBeautifier
 
         match_position = match.begin(0)
 
-        previous_character = match_position.zero? ? nil : sql[match_position - 1]
-        next_character = match_position + keyword.length >= sql.length ? nil : sql[match_position + keyword.length]
+        previous_character = character_before(sql, match_position)
+        next_character = character_after(sql, match_position, keyword.length)
 
         return match_position if word_boundary?(previous_character) && word_boundary?(next_character) && top_level?(sql, match_position)
 
@@ -48,7 +48,15 @@ module SqlBeautifier
 
       boundaries.each_with_index do |boundary, boundary_index|
         content_start = boundary[:position] + boundary[:keyword].length
-        content_end = boundary_index + 1 < boundaries.length ? boundaries[boundary_index + 1][:position] : sql.length
+
+        content_end = begin
+          if boundary_index + 1 < boundaries.length
+            boundaries[boundary_index + 1][:position]
+          else
+            sql.length
+          end
+        end
+
         clause_symbol = boundary[:keyword].tr(" ", "_").to_sym
 
         clauses[clause_symbol] = sql[content_start...content_end].strip
@@ -71,10 +79,10 @@ module SqlBeautifier
         if inside_string_literal
           current_segment << character
 
-          if character == "'" && text[position + 1] == "'"
+          if escaped_single_quote?(text, position)
             position += 1
             current_segment << text[position]
-          elsif character == "'"
+          elsif character == Constants::SINGLE_QUOTE
             inside_string_literal = false
           end
 
@@ -85,10 +93,10 @@ module SqlBeautifier
         if inside_quoted_identifier
           current_segment << character
 
-          if character == '"' && text[position + 1] == '"'
+          if escaped_double_quote?(text, position)
             position += 1
             current_segment << text[position]
-          elsif character == '"'
+          elsif character == Constants::DOUBLE_QUOTE
             inside_quoted_identifier = false
           end
 
@@ -97,23 +105,23 @@ module SqlBeautifier
         end
 
         case character
-        when "'"
+        when Constants::SINGLE_QUOTE
           inside_string_literal = true
           current_segment << character
 
-        when '"'
+        when Constants::DOUBLE_QUOTE
           inside_quoted_identifier = true
           current_segment << character
 
-        when "("
+        when Constants::OPEN_PARENTHESIS
           parenthesis_depth += 1
           current_segment << character
 
-        when ")"
+        when Constants::CLOSE_PARENTHESIS
           parenthesis_depth = [parenthesis_depth - 1, 0].max
           current_segment << character
 
-        when ","
+        when Constants::COMMA
           if parenthesis_depth.zero?
             segments << current_segment.strip
             current_segment = +""
@@ -132,10 +140,118 @@ module SqlBeautifier
       segments
     end
 
+    def split_top_level_conditions(text)
+      conjunction_boundaries = scan_top_level_conjunctions(text)
+
+      return [[nil, text.strip]] if conjunction_boundaries.empty?
+
+      condition_pairs = []
+      first_condition_text = text[0...conjunction_boundaries.first[:position]].strip
+      condition_pairs << [nil, first_condition_text]
+
+      conjunction_boundaries.each_with_index do |boundary, boundary_index|
+        content_start = boundary[:position] + boundary[:conjunction].length
+
+        content_end = begin
+          if boundary_index + 1 < conjunction_boundaries.length
+            conjunction_boundaries[boundary_index + 1][:position]
+          else
+            text.length
+          end
+        end
+
+        condition_text = text[content_start...content_end].strip
+
+        condition_pairs << [boundary[:conjunction], condition_text]
+      end
+
+      condition_pairs
+    end
+
+    def find_matching_parenthesis(text, opening_position)
+      parenthesis_depth = 0
+      inside_string_literal = false
+      inside_quoted_identifier = false
+      position = opening_position
+
+      while position < text.length
+        character = text[position]
+
+        if inside_string_literal
+          if escaped_single_quote?(text, position)
+            position += 2
+            next
+          elsif character == Constants::SINGLE_QUOTE
+            inside_string_literal = false
+          end
+
+          position += 1
+          next
+        end
+
+        if inside_quoted_identifier
+          if escaped_double_quote?(text, position)
+            position += 2
+            next
+          elsif character == Constants::DOUBLE_QUOTE
+            inside_quoted_identifier = false
+          end
+
+          position += 1
+          next
+        end
+
+        case character
+        when Constants::SINGLE_QUOTE
+          inside_string_literal = true
+        when Constants::DOUBLE_QUOTE
+          inside_quoted_identifier = true
+        when Constants::OPEN_PARENTHESIS
+          parenthesis_depth += 1
+        when Constants::CLOSE_PARENTHESIS
+          parenthesis_depth -= 1
+          return position if parenthesis_depth.zero?
+        end
+
+        position += 1
+      end
+
+      nil
+    end
+
+    def outer_parentheses_wrap_all?(text)
+      trimmed_text = text.strip
+      return false unless trimmed_text.start_with?(Constants::OPEN_PARENTHESIS)
+
+      closing_parenthesis_position = find_matching_parenthesis(trimmed_text, 0)
+
+      closing_parenthesis_position == trimmed_text.length - 1
+    end
+
     def word_boundary?(character)
       character.nil? || character !~ IDENTIFIER_CHARACTER
     end
 
+    def character_before(text, position)
+      return nil if position.zero?
+
+      text[position - 1]
+    end
+
+    def character_after(text, position, offset)
+      return nil if position + offset >= text.length
+
+      text[position + offset]
+    end
+
+    def escaped_single_quote?(text, position)
+      text[position] == Constants::SINGLE_QUOTE && text[position + 1] == Constants::SINGLE_QUOTE
+    end
+
+    def escaped_double_quote?(text, position)
+      text[position] == Constants::DOUBLE_QUOTE && text[position + 1] == Constants::DOUBLE_QUOTE
+    end
+
     def top_level?(sql, target_position)
       parenthesis_depth = 0
       inside_string_literal = false
@@ -146,10 +262,10 @@ module SqlBeautifier
         character = sql[position]
 
         if inside_string_literal
-          if character == "'" && sql[position + 1] == "'"
+          if escaped_single_quote?(sql, position)
             position += 2
             next
-          elsif character == "'"
+          elsif character == Constants::SINGLE_QUOTE
             inside_string_literal = false
           end
 
@@ -158,10 +274,10 @@ module SqlBeautifier
         end
 
         if inside_quoted_identifier
-          if character == '"' && sql[position + 1] == '"'
+          if escaped_double_quote?(sql, position)
             position += 2
             next
-          elsif character == '"'
+          elsif character == Constants::DOUBLE_QUOTE
             inside_quoted_identifier = false
           end
 
@@ -170,13 +286,13 @@ module SqlBeautifier
         end
 
         case character
-        when "'"
+        when Constants::SINGLE_QUOTE
           inside_string_literal = true
-        when '"'
+        when Constants::DOUBLE_QUOTE
           inside_quoted_identifier = true
-        when "("
+        when Constants::OPEN_PARENTHESIS
           parenthesis_depth += 1
-        when ")"
+        when Constants::CLOSE_PARENTHESIS
           parenthesis_depth = [parenthesis_depth - 1, 0].max
         end
 
@@ -185,5 +301,92 @@ module SqlBeautifier
 
       parenthesis_depth.zero? && !inside_string_literal && !inside_quoted_identifier
     end
+
+    def scan_top_level_conjunctions(text)
+      conjunction_boundaries = []
+      parenthesis_depth = 0
+      inside_string_literal = false
+      inside_quoted_identifier = false
+      inside_between = false
+      position = 0
+
+      while position < text.length
+        character = text[position]
+
+        if inside_string_literal
+          if escaped_single_quote?(text, position)
+            position += 2
+          elsif character == Constants::SINGLE_QUOTE
+            inside_string_literal = false
+            position += 1
+          else
+            position += 1
+          end
+          next
+        end
+
+        if inside_quoted_identifier
+          if escaped_double_quote?(text, position)
+            position += 2
+          elsif character == Constants::DOUBLE_QUOTE
+            inside_quoted_identifier = false
+            position += 1
+          else
+            position += 1
+          end
+          next
+        end
+
+        case character
+        when Constants::SINGLE_QUOTE
+          inside_string_literal = true
+        when Constants::DOUBLE_QUOTE
+          inside_quoted_identifier = true
+        when Constants::OPEN_PARENTHESIS
+          parenthesis_depth += 1
+        when Constants::CLOSE_PARENTHESIS
+          parenthesis_depth = [parenthesis_depth - 1, 0].max
+        else
+          if parenthesis_depth.zero?
+            inside_between = true if keyword_at?(text, position, Constants::BETWEEN_KEYWORD)
+
+            matched_conjunction = detect_conjunction_at(text, position)
+
+            if matched_conjunction
+              if matched_conjunction == "and" && inside_between
+                inside_between = false
+              else
+                conjunction_boundaries << {
+                  conjunction: matched_conjunction,
+                  position: position,
+                }
+              end
+
+              position += matched_conjunction.length
+              next
+            end
+          end
+        end
+
+        position += 1
+      end
+
+      conjunction_boundaries
+    end
+
+    def keyword_at?(text, position, keyword)
+      return false unless text[position, keyword.length]&.downcase == keyword
+
+      previous_character = character_before(text, position)
+      next_character = character_after(text, position, keyword.length)
+
+      word_boundary?(previous_character) && word_boundary?(next_character)
+    end
+
+    def detect_conjunction_at(text, position)
+      Constants::CONJUNCTIONS.detect do |conjunction|
+        keyword_at?(text, position, conjunction)
+      end
+    end
   end
 end

data/lib/sql_beautifier/util.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module Util
+    module_function
+
+    def whitespace(length)
+      " " * length
+    end
+
+    def upper_pascal_case(name)
+      name.split("_").map(&:capitalize).join("_")
+    end
+
+    def first_word(text)
+      text.strip.split(Constants::WHITESPACE_REGEX).first
+    end
+
+    def strip_outer_parentheses(text)
+      stripped_text = text.strip
+      return stripped_text unless stripped_text.start_with?(Constants::OPEN_PARENTHESIS) && stripped_text.end_with?(Constants::CLOSE_PARENTHESIS)
+
+      stripped_text[1...-1].strip
+    end
+
+    def double_quote_string(value)
+      return if value.nil?
+
+      "#{Constants::DOUBLE_QUOTE}#{value}#{Constants::DOUBLE_QUOTE}"
+    end
+
+    def escape_double_quote(value)
+      return if value.nil?
+
+      value.gsub(Constants::DOUBLE_QUOTE, Constants::ESCAPED_DOUBLE_QUOTE)
+    end
+
+    def keyword_padding(keyword)
+      formatted_keyword = format_keyword(keyword)
+      padding_width = [SqlBeautifier.config_for(:keyword_column_width) - formatted_keyword.length, 1].max
+
+      "#{formatted_keyword}#{whitespace(padding_width)}"
+    end
+
+    def continuation_padding
+      whitespace(SqlBeautifier.config_for(:keyword_column_width))
+    end
+
+    def format_keyword(keyword)
+      case SqlBeautifier.config_for(:keyword_case)
+      when :upper
+        keyword.upcase
+      else
+        keyword.downcase
+      end
+    end
+
+    def format_table_name(name)
+      case SqlBeautifier.config_for(:table_name_format)
+      when :lowercase
+        name.downcase
+      else
+        upper_pascal_case(name)
+      end
+    end
+  end
+end

data/lib/sql_beautifier/version.rb

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

data/lib/sql_beautifier.rb

@@ -4,9 +4,16 @@ require "active_support/core_ext/object/blank"
 
 require_relative "sql_beautifier/version"
 require_relative "sql_beautifier/constants"
+require_relative "sql_beautifier/util"
+require_relative "sql_beautifier/configuration"
+
 require_relative "sql_beautifier/normalizer"
 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/clauses/base"
+require_relative "sql_beautifier/clauses/condition_clause"
 require_relative "sql_beautifier/clauses/select"
 require_relative "sql_beautifier/clauses/from"
 require_relative "sql_beautifier/clauses/where"
@@ -26,4 +33,20 @@ module SqlBeautifier
 
     Formatter.call(value)
   end
+
+  def configuration
+    @configuration ||= Configuration.new
+  end
+
+  def configure
+    yield configuration
+  end
+
+  def config_for(key)
+    configuration.public_send(key)
+  end
+
+  def reset_configuration!
+    @configuration = Configuration.new
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql_beautifier
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Kinnell Shah
@@ -38,6 +38,7 @@ files:
 - README.md
 - lib/sql_beautifier.rb
 - lib/sql_beautifier/clauses/base.rb
+- lib/sql_beautifier/clauses/condition_clause.rb
 - lib/sql_beautifier/clauses/from.rb
 - lib/sql_beautifier/clauses/group_by.rb
 - lib/sql_beautifier/clauses/having.rb
@@ -45,10 +46,15 @@ files:
 - lib/sql_beautifier/clauses/order_by.rb
 - lib/sql_beautifier/clauses/select.rb
 - lib/sql_beautifier/clauses/where.rb
+- lib/sql_beautifier/condition_formatter.rb
+- lib/sql_beautifier/configuration.rb
 - lib/sql_beautifier/constants.rb
 - lib/sql_beautifier/formatter.rb
 - lib/sql_beautifier/normalizer.rb
+- lib/sql_beautifier/subquery_formatter.rb
+- lib/sql_beautifier/table_registry.rb
 - lib/sql_beautifier/tokenizer.rb
+- lib/sql_beautifier/util.rb
 - lib/sql_beautifier/version.rb
 homepage: https://github.com/kinnell/sql_beautifier
 licenses: