sql_beautifier 0.6.0 → 0.7.0

data/lib/sql_beautifier/tokenizer.rb

@@ -2,14 +2,12 @@
 
 module SqlBeautifier
   module Tokenizer
-    IDENTIFIER_CHARACTER = %r{[[:alnum:]_$]}
-    SENTINEL_MAX_LOOKBACK = 20
-
     module_function
 
     def find_top_level_keyword(sql, keyword)
       keyword_pattern = %r{#{Regexp.escape(keyword)}}i
       search_position = 0
+      scanner = Scanner.new(sql)
 
       while search_position < sql.length
         match = sql.match(keyword_pattern, search_position)
@@ -17,15 +15,15 @@ module SqlBeautifier
 
         match_position = match.begin(0)
 
-        if inside_sentinel?(sql, match_position)
-          search_position = sentinel_end_position(sql, match_position) || (match_position + 1)
+        if scanner.inside_sentinel?(match_position)
+          search_position = scanner.sentinel_end_position(match_position) || (match_position + 1)
           next
         end
 
-        previous_character = character_before(sql, match_position)
-        next_character = character_after(sql, match_position, keyword.length)
+        previous_character = scanner.character_before(match_position)
+        next_character = scanner.character_after(match_position, keyword.length)
 
-        return match_position if word_boundary?(previous_character) && word_boundary?(next_character) && top_level?(sql, match_position)
+        return match_position if scanner.word_boundary?(previous_character) && scanner.word_boundary?(next_character) && top_level?(sql, match_position)
 
         search_position = match_position + 1
       end
@@ -72,70 +70,30 @@ module SqlBeautifier
     end
 
     def split_by_top_level_commas(text)
+      scanner = Scanner.new(text)
       segments = []
       current_segment = +""
-      parenthesis_depth = 0
-      inside_string_literal = false
-      inside_quoted_identifier = false
-      position = 0
-
-      while position < text.length
-        character = text[position]
-
-        if inside_string_literal
-          current_segment << character
 
-          if escaped_single_quote?(text, position)
-            position += 1
-            current_segment << text[position]
-          elsif character == Constants::SINGLE_QUOTE
-            inside_string_literal = false
-          end
-
-          position += 1
+      until scanner.finished?
+        consumed = scanner.scan_quoted_or_sentinel!
+        if consumed
+          current_segment << consumed
           next
         end
 
-        if inside_quoted_identifier
-          current_segment << character
-
-          if escaped_double_quote?(text, position)
-            position += 1
-            current_segment << text[position]
-          elsif character == Constants::DOUBLE_QUOTE
-            inside_quoted_identifier = false
-          end
-
-          position += 1
-          next
-        end
-
-        if sentinel_at?(text, position)
-          end_position = sentinel_end_position(text, position)
-          current_segment << text[position...end_position]
-          position = end_position
-          next
-        end
+        character = scanner.current_char
 
         case character
-        when Constants::SINGLE_QUOTE
-          inside_string_literal = true
-          current_segment << character
-
-        when Constants::DOUBLE_QUOTE
-          inside_quoted_identifier = true
-          current_segment << character
-
         when Constants::OPEN_PARENTHESIS
-          parenthesis_depth += 1
+          scanner.increment_depth!
           current_segment << character
 
         when Constants::CLOSE_PARENTHESIS
-          parenthesis_depth = [parenthesis_depth - 1, 0].max
+          scanner.decrement_depth!
           current_segment << character
 
         when Constants::COMMA
-          if parenthesis_depth.zero?
+          if scanner.parenthesis_depth.zero?
             segments << current_segment.strip
             current_segment = +""
           else
@@ -146,7 +104,7 @@ module SqlBeautifier
           current_segment << character
         end
 
-        position += 1
+        scanner.advance!
       end
 
       segments << current_segment.strip unless current_segment.strip.empty?
@@ -181,238 +139,64 @@ module SqlBeautifier
       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
-
-        if sentinel_at?(text, position)
-          position = sentinel_end_position(text, position)
-          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 = Scanner.new(trimmed_text).find_matching_parenthesis(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 dollar_quote_delimiter_at(text, position)
-      return "$$" if text[position, 2] == "$$"
-      return unless text[position] == "$"
-
-      closing_dollar_position = text.index("$", position + 1)
-      return unless closing_dollar_position
-
-      delimiter = text[position..closing_dollar_position]
-      tag = delimiter[1..-2]
-      return unless tag.match?(%r{\A[[:alpha:]_][[:alnum:]_]*\z})
-
-      delimiter
-    end
-
-    def sentinel_at?(text, position)
-      text[position, CommentStripper::SENTINEL_PREFIX.length] == CommentStripper::SENTINEL_PREFIX
-    end
-
-    def sentinel_end_position(text, position)
-      closing = text.index(CommentStripper::SENTINEL_SUFFIX, position + CommentStripper::SENTINEL_PREFIX.length)
-      return position + 1 unless closing
-
-      closing + CommentStripper::SENTINEL_SUFFIX.length
-    end
-
-    def inside_sentinel?(text, position)
-      search_start = [position - SENTINEL_MAX_LOOKBACK, 0].max
-      prefix_position = text.rindex(CommentStripper::SENTINEL_PREFIX, position)
-      return false unless prefix_position && prefix_position >= search_start
-
-      end_position = sentinel_end_position(text, prefix_position)
-      position < end_position
-    end
-
     def top_level?(sql, target_position)
-      parenthesis_depth = 0
-      inside_string_literal = false
-      inside_quoted_identifier = false
-      position = 0
-
-      while position < target_position
-        character = sql[position]
-
-        if inside_string_literal
-          if escaped_single_quote?(sql, position)
-            position += 2
-            next
-          elsif character == Constants::SINGLE_QUOTE
-            inside_string_literal = false
-          end
-
-          position += 1
-          next
-        end
+      scanner = Scanner.new(sql)
 
-        if inside_quoted_identifier
-          if escaped_double_quote?(sql, position)
-            position += 2
-            next
-          elsif character == Constants::DOUBLE_QUOTE
-            inside_quoted_identifier = false
-          end
-
-          position += 1
-          next
-        end
-
-        if sentinel_at?(sql, position)
-          position = sentinel_end_position(sql, position)
-          next
-        end
+      while scanner.position < target_position
+        next if scanner.skip_quoted_or_sentinel!
 
-        case character
+        case scanner.current_char
         when Constants::SINGLE_QUOTE
-          inside_string_literal = true
+          scanner.enter_single_quote!
         when Constants::DOUBLE_QUOTE
-          inside_quoted_identifier = true
+          scanner.enter_double_quote!
         when Constants::OPEN_PARENTHESIS
-          parenthesis_depth += 1
+          scanner.increment_depth!
+          scanner.advance!
         when Constants::CLOSE_PARENTHESIS
-          parenthesis_depth = [parenthesis_depth - 1, 0].max
+          scanner.decrement_depth!
+          scanner.advance!
+        else
+          scanner.advance!
         end
-
-        position += 1
       end
 
-      parenthesis_depth.zero? && !inside_string_literal && !inside_quoted_identifier
+      scanner.top_level?
     end
 
     def scan_top_level_conjunctions(text)
+      scanner = Scanner.new(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
+      until scanner.finished?
+        next if scanner.skip_quoted_or_sentinel!
 
-        if sentinel_at?(text, position)
-          position = sentinel_end_position(text, position)
-          next
-        end
-
-        case character
+        case scanner.current_char
         when Constants::SINGLE_QUOTE
-          inside_string_literal = true
+          scanner.enter_single_quote!
         when Constants::DOUBLE_QUOTE
-          inside_quoted_identifier = true
+          scanner.enter_double_quote!
         when Constants::OPEN_PARENTHESIS
-          parenthesis_depth += 1
+          scanner.increment_depth!
+          scanner.advance!
         when Constants::CLOSE_PARENTHESIS
-          parenthesis_depth = [parenthesis_depth - 1, 0].max
+          scanner.decrement_depth!
+          scanner.advance!
         else
-          if parenthesis_depth.zero?
-            inside_between = true if keyword_at?(text, position, Constants::BETWEEN_KEYWORD)
+          if scanner.parenthesis_depth.zero?
+            inside_between = true if scanner.keyword_at?(Constants::BETWEEN_KEYWORD)
 
-            matched_conjunction = detect_conjunction_at(text, position)
+            matched_conjunction = scanner.detect_conjunction_at
 
             if matched_conjunction
               if matched_conjunction == "and" && inside_between
@@ -420,35 +204,20 @@ module SqlBeautifier
               else
                 conjunction_boundaries << {
                   conjunction: matched_conjunction,
-                  position: position,
+                  position: scanner.position,
                 }
               end
 
-              position += matched_conjunction.length
+              scanner.advance!(matched_conjunction.length)
               next
             end
           end
-        end
 
-        position += 1
+          scanner.advance!
+        end
       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/types.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "dry-types"
+
+module SqlBeautifier
+  module Types
+    include Dry.Types()
+  end
+end

data/lib/sql_beautifier/version.rb

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

data/lib/sql_beautifier.rb

@@ -5,18 +5,25 @@ 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/base"
 require_relative "sql_beautifier/configuration"
+require_relative "sql_beautifier/types"
 
-require_relative "sql_beautifier/comment_stripper"
-require_relative "sql_beautifier/comment_restorer"
+require_relative "sql_beautifier/scanner"
+require_relative "sql_beautifier/comment"
+require_relative "sql_beautifier/comment_parser"
 require_relative "sql_beautifier/normalizer"
 require_relative "sql_beautifier/tokenizer"
 require_relative "sql_beautifier/statement_splitter"
+require_relative "sql_beautifier/table_reference"
 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/join"
+require_relative "sql_beautifier/expression"
+require_relative "sql_beautifier/sort_expression"
+require_relative "sql_beautifier/condition"
+require_relative "sql_beautifier/cte_definition"
+require_relative "sql_beautifier/cte_query"
+require_relative "sql_beautifier/create_table_as"
 require_relative "sql_beautifier/clauses/base"
 require_relative "sql_beautifier/clauses/condition_clause"
 require_relative "sql_beautifier/clauses/select"
@@ -26,6 +33,7 @@ require_relative "sql_beautifier/clauses/group_by"
 require_relative "sql_beautifier/clauses/order_by"
 require_relative "sql_beautifier/clauses/having"
 require_relative "sql_beautifier/clauses/limit"
+require_relative "sql_beautifier/query"
 require_relative "sql_beautifier/formatter"
 require_relative "sql_beautifier/statement_assembler"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql_beautifier
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Kinnell Shah
@@ -23,6 +23,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.9'
 description: 'Formats raw SQL into a clean, consistent style with lowercase keywords,
   padded keyword alignment, and vertically separated clauses.
 
@@ -37,6 +65,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/sql_beautifier.rb
+- lib/sql_beautifier/base.rb
 - lib/sql_beautifier/clauses/base.rb
 - lib/sql_beautifier/clauses/condition_clause.rb
 - lib/sql_beautifier/clauses/from.rb
@@ -46,20 +75,27 @@ files:
 - lib/sql_beautifier/clauses/order_by.rb
 - lib/sql_beautifier/clauses/select.rb
 - lib/sql_beautifier/clauses/where.rb
-- lib/sql_beautifier/comment_restorer.rb
-- lib/sql_beautifier/comment_stripper.rb
-- lib/sql_beautifier/condition_formatter.rb
+- lib/sql_beautifier/comment.rb
+- lib/sql_beautifier/comment_parser.rb
+- lib/sql_beautifier/condition.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/create_table_as.rb
+- lib/sql_beautifier/cte_definition.rb
+- lib/sql_beautifier/cte_query.rb
+- lib/sql_beautifier/expression.rb
 - lib/sql_beautifier/formatter.rb
+- lib/sql_beautifier/join.rb
 - lib/sql_beautifier/normalizer.rb
+- lib/sql_beautifier/query.rb
+- lib/sql_beautifier/scanner.rb
+- lib/sql_beautifier/sort_expression.rb
 - lib/sql_beautifier/statement_assembler.rb
 - lib/sql_beautifier/statement_splitter.rb
-- lib/sql_beautifier/subquery_formatter.rb
+- lib/sql_beautifier/table_reference.rb
 - lib/sql_beautifier/table_registry.rb
 - lib/sql_beautifier/tokenizer.rb
+- lib/sql_beautifier/types.rb
 - lib/sql_beautifier/util.rb
 - lib/sql_beautifier/version.rb
 homepage: https://github.com/kinnell/sql_beautifier

data/lib/sql_beautifier/comment_restorer.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module SqlBeautifier
-  class CommentRestorer
-    def self.call(formatted_sql, comment_map)
-      return formatted_sql if comment_map.empty?
-
-      new(formatted_sql, comment_map).call
-    end
-
-    def initialize(formatted_sql, comment_map)
-      @formatted_sql = formatted_sql
-      @comment_map = comment_map
-    end
-
-    def call
-      result = @formatted_sql
-
-      @comment_map.each do |index, entry|
-        sentinel = "#{CommentStripper::SENTINEL_PREFIX}#{index}#{CommentStripper::SENTINEL_SUFFIX}"
-
-        result = begin
-          case entry[:type]
-          when :blocks
-            restore_block_comment(result, sentinel, entry[:text])
-          when :separate_line
-            restore_separate_line_comment(result, sentinel, entry[:text])
-          when :inline
-            restore_inline_comment(result, sentinel, entry[:text])
-          else
-            result
-          end
-        end
-      end
-
-      result
-    end
-
-    private
-
-    def restore_block_comment(sql, sentinel, comment_text)
-      sql.sub(sentinel, comment_text)
-    end
-
-    def restore_separate_line_comment(sql, sentinel, comment_text)
-      sql.sub(%r{#{Regexp.escape(sentinel)}[ \n]?}, "#{comment_text}\n")
-    end
-
-    def restore_inline_comment(sql, sentinel, comment_text)
-      pattern = %r{ ?#{Regexp.escape(sentinel)}([^\n]*)}
-      sql.sub(pattern) do
-        trailing_content = Regexp.last_match(1)
-
-        if trailing_content.strip.empty?
-          " #{comment_text}"
-        else
-          "#{trailing_content.strip} #{comment_text}"
-        end
-      end
-    end
-  end
-end