sql_beautifier 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52e4fa6ef07975cadc1b7eaf77dbf0f3000552b1a91268edd22b64a1407f85b0
-  data.tar.gz: bcda04e6aecb08a400bedee58ee41b8813030fb202f51e0d1d44365afae72990
+  metadata.gz: bcf549a9025b3f1baa8e3e6586154ce0e4b9529985f8e54b49ff241e4a24cd19
+  data.tar.gz: ce6eb31a10ad63436442bf0a27d4054857540a03d2b799ecf40db46246ac0852
 SHA512:
-  metadata.gz: 48911b7894e8251f47c2256da78888ba1fd992f65341d3fa70cc4429d92a7ba7008d4564360eca5e860e91d61f59e0718207abdc61680852e3a8614c478264f3
-  data.tar.gz: 5b3c2ab5629a09a6a4c6477c3aaa094f8d03bf1123a1c2cfd1f217ff15463b011d0faf8b8a24e864358ec62a4bf540acc1921400fd0ff7c25d74e2579e3d6e43
+  metadata.gz: f2bed68bdfff3e132819a44756f57da8b8e8445738d85e967ea98d108510afe4c2840f0f4a2ef592bf0cbbccac8facfaf247b31e2f8810c6e22d65c8ecee551d
+  data.tar.gz: 595b15be6f7f1a6b7541580d679ef0bde692bca70e4cffec251ea4f995aa3f54c17305b28b2a62ee0172ed40ca1137a013f4041d5ecf2624bcd22a7563a52672

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [X.X.X] - YYYY-MM-DD
 
+## [0.9.2] - 2026-03-30
+
+- Fix derived tables (subqueries in `FROM` clauses) losing their content during formatting — `TableRegistry#parse_references` used a regex split that did not respect parenthesis depth, causing JOIN keywords inside derived table subqueries to be treated as top-level boundaries
+- Add derived table support to `TableReference` — segments starting with `(` are parsed as derived tables, preserving the full expression and extracting the alias from text after the closing `)`
+- Extract `find_all_top_level_join_positions` and `find_earliest_top_level_join_keyword` into `Tokenizer` for shared use by `Clauses::From` and `TableRegistry`
+- Improve subquery indentation for `FROM`-line subqueries — derived tables now align with keyword column width, matching the existing behavior for `WHERE`-line subqueries
+- Fix aliasless derived tables in `FROM` clauses raising `NoMethodError` or receiving malformed auto-generated aliases — lookup now falls back to the full derived-table expression when no alias is present and alias assignment skips aliasless derived tables
+
 ## [0.9.1] - 2026-03-29
 
 ## [0.9.0] - 2026-03-29

data/README.md

@@ -469,6 +469,23 @@ where   id in (
 
 Nested subqueries increase indentation at each level.
 
+Derived tables (subqueries in `FROM` clauses) are also supported — the subquery content is recursively formatted and the alias is preserved:
+
+```ruby
+SqlBeautifier.call("SELECT active_users.id FROM (SELECT id FROM users WHERE active = true) AS active_users")
+```
+
+Produces:
+
+```sql
+select  active_users.id
+from    (
+            select  id
+            from    Users u
+            where   active = true
+        ) active_users;
+```
+
 ### Trailing Semicolons
 
 By default, each formatted statement ends with a `;`:

data/lib/sql_beautifier/clauses/from.rb

@@ -18,7 +18,8 @@ module SqlBeautifier
       def call
         join_parts = split_join_parts
         primary_table_text = join_parts.shift.strip
-        primary_reference = @table_registry.reference_for(Util.first_word(primary_table_text))
+        primary_lookup_name = TableReference.derived_table_lookup_name_from(primary_table_text) || Util.first_word(primary_table_text)
+        primary_reference = @table_registry.reference_for(primary_lookup_name)
         trailing_sentinels = Join.extract_trailing_sentinels(primary_table_text)
 
         lines = []
@@ -42,7 +43,7 @@ module SqlBeautifier
 
       def split_join_parts
         from_content = @value.strip
-        join_keyword_positions = find_all_join_keyword_positions(from_content)
+        join_keyword_positions = Tokenizer.find_all_top_level_join_positions(from_content)
 
         return [from_content] if join_keyword_positions.empty?
 
@@ -62,41 +63,6 @@ module SqlBeautifier
 
         parts
       end
-
-      def find_all_join_keyword_positions(text)
-        positions = []
-        search_offset = 0
-
-        while search_offset < text.length
-          earliest_match = find_earliest_join_keyword(text, search_offset)
-          break unless earliest_match
-
-          positions << earliest_match
-          search_offset = earliest_match[:position] + earliest_match[:keyword].length
-        end
-
-        positions
-      end
-
-      def find_earliest_join_keyword(text, search_offset)
-        earliest_match = nil
-
-        Constants::JOIN_KEYWORDS_BY_LENGTH.each do |keyword|
-          remaining_text = text[search_offset..]
-          keyword_position = Tokenizer.find_top_level_keyword(remaining_text, keyword)
-          next unless keyword_position
-
-          absolute_position = search_offset + keyword_position
-          next if earliest_match && absolute_position >= earliest_match[:position]
-
-          earliest_match = {
-            position: absolute_position,
-            keyword: keyword,
-          }
-        end
-
-        earliest_match
-      end
     end
   end
 end

data/lib/sql_beautifier/join.rb

@@ -22,11 +22,13 @@ module SqlBeautifier
         conditions = []
       end
 
-      table_name = Util.first_word(table_text)
-      table_ref = table_registry.reference_for(table_name)
+      table_lookup_name = TableReference.derived_table_lookup_name_from(table_text) || Util.first_word(table_text)
+      table_reference = table_registry.reference_for(table_lookup_name)
+      return unless table_reference
+
       trailing_sentinels = extract_trailing_sentinels(table_text)
 
-      new(keyword: keyword, table_reference: table_ref, trailing_sentinels: trailing_sentinels, conditions: conditions)
+      new(keyword: keyword, table_reference: table_reference, trailing_sentinels: trailing_sentinels, conditions: conditions)
     end
 
     def self.extract_keyword(join_text)

data/lib/sql_beautifier/query.rb

@@ -11,7 +11,7 @@ module SqlBeautifier
     ].freeze
 
     LEADING_WHITESPACE_PATTERN = %r{\A[[:space:]]*}
-    WHERE_PREFIX_PATTERN = %r{\Awhere(?:[[:space:]]|$)}i
+    CLAUSE_KEYWORD_PREFIX_PATTERN = %r{\A(?:where|from)(?:[[:space:]]|$)}i
 
     attr_reader :clauses
     attr_reader :depth
@@ -88,7 +88,7 @@ module SqlBeautifier
       line_before_subquery = text[line_start_position...subquery_position]
       line_leading_spaces = line_before_subquery[LEADING_WHITESPACE_PATTERN].to_s.length
 
-      return default_base_indent unless line_before_subquery.lstrip.match?(WHERE_PREFIX_PATTERN)
+      return default_base_indent unless line_before_subquery.lstrip.match?(CLAUSE_KEYWORD_PREFIX_PATTERN)
 
       default_base_indent + line_leading_spaces + SqlBeautifier.config_for(:keyword_column_width)
     end

data/lib/sql_beautifier/table_reference.rb

@@ -5,13 +5,33 @@ module SqlBeautifier
     option :name
     option :explicit_alias, default: -> {}
     option :assigned_alias, default: -> {}
+    option :derived_table_expression, default: -> {}
 
     def self.parse(segment_text)
       table_specification = table_specification_text(segment_text)
-      table_name = Util.first_word(table_specification)
+      stripped_specification = table_specification.strip
+
+      return parse_derived_table(stripped_specification) if stripped_specification.start_with?(Constants::OPEN_PARENTHESIS)
+
+      table_name = Util.first_word(stripped_specification)
       return unless table_name
 
-      new(name: table_name, explicit_alias: extract_explicit_alias(table_specification))
+      new(name: table_name, explicit_alias: extract_explicit_alias(stripped_specification))
+    end
+
+    def self.parse_derived_table(table_specification)
+      closing_position = Scanner.new(table_specification).find_matching_parenthesis(0)
+      return unless closing_position
+
+      expression = table_specification[0..closing_position]
+      remaining = table_specification[(closing_position + 1)..].strip
+      derived_alias = extract_derived_table_alias(remaining)
+
+      new(
+        name: derived_alias || expression,
+        explicit_alias: derived_alias,
+        derived_table_expression: expression
+      )
     end
 
     def self.table_specification_text(segment_text)
@@ -32,6 +52,36 @@ module SqlBeautifier
       end
     end
 
+    def self.derived_table_lookup_name_from(text)
+      stripped_text = text.strip
+      return unless stripped_text.start_with?(Constants::OPEN_PARENTHESIS)
+
+      closing_position = Scanner.new(stripped_text).find_matching_parenthesis(0)
+      return unless closing_position
+
+      expression = stripped_text[0..closing_position]
+      remaining_text = stripped_text[(closing_position + 1)..].strip
+      derived_alias = extract_derived_table_alias(remaining_text)
+
+      derived_alias || expression
+    end
+
+    def self.extract_derived_table_alias(remaining_text)
+      return if remaining_text.empty?
+
+      words = remaining_text.split(Constants::WHITESPACE_REGEX)
+
+      if words.first&.downcase == "as"
+        words[1]
+      else
+        words.first
+      end
+    end
+
+    def derived_table?
+      @derived_table_expression.present?
+    end
+
     def formatted_name
       Util.format_table_name(@name)
     end
@@ -45,7 +95,14 @@ module SqlBeautifier
     end
 
     def render(trailing_sentinels: nil)
-      formatted = alias_name ? "#{formatted_name} #{alias_name}" : formatted_name
+      formatted = begin
+        if derived_table?
+          alias_name ? "#{@derived_table_expression} #{alias_name}" : @derived_table_expression
+        else
+          alias_name ? "#{formatted_name} #{alias_name}" : formatted_name
+        end
+      end
+
       trailing_sentinels&.any? ? "#{formatted} #{trailing_sentinels.join(' ')}" : formatted
     end
   end

data/lib/sql_beautifier/table_registry.rb

@@ -79,6 +79,11 @@ module SqlBeautifier
           next
         end
 
+        if reference.derived_table?
+          @references_by_name[reference.name] = reference
+          next
+        end
+
         initials = table_initials(reference.name)
         duplicate_initials_counts[initials] += 1 if initials_occurrence_counts[initials] > 1
 
@@ -109,7 +114,7 @@ module SqlBeautifier
       occurrence_counts = Hash.new(0)
 
       @references.each do |reference|
-        next if reference.explicit_alias
+        next if reference.explicit_alias || reference.derived_table?
 
         occurrence_counts[table_initials(reference.name)] += 1
       end
@@ -136,16 +141,26 @@ module SqlBeautifier
     end
 
     def parse_references(from_content)
-      split_segments = from_content.strip.split(Constants::JOIN_KEYWORD_PATTERN)
+      from_text = from_content.strip
+      join_positions = Tokenizer.find_all_top_level_join_positions(from_text)
 
       references = []
 
-      primary_segment = split_segments.shift.strip
+      primary_end = join_positions.any? ? join_positions.first[:position] : from_text.length
+      primary_segment = from_text[0...primary_end].strip
       references << TableReference.parse(primary_segment)
 
-      split_segments.each_slice(2) do |_join_keyword, join_content|
-        next unless join_content
+      join_positions.each_with_index do |join_info, index|
+        content_start = join_info[:position] + join_info[:keyword].length
+        content_end = begin
+          if index + 1 < join_positions.length
+            join_positions[index + 1][:position]
+          else
+            from_text.length
+          end
+        end
 
+        join_content = from_text[content_start...content_end].strip
         references << TableReference.parse(join_content)
       end
 

data/lib/sql_beautifier/tokenizer.rb

@@ -173,6 +173,41 @@ module SqlBeautifier
       scanner.top_level?
     end
 
+    def find_all_top_level_join_positions(text)
+      positions = []
+      search_offset = 0
+
+      while search_offset < text.length
+        earliest_match = find_earliest_top_level_join_keyword(text, search_offset)
+        break unless earliest_match
+
+        positions << earliest_match
+        search_offset = earliest_match[:position] + earliest_match[:keyword].length
+      end
+
+      positions
+    end
+
+    def find_earliest_top_level_join_keyword(text, search_offset)
+      earliest_match = nil
+
+      Constants::JOIN_KEYWORDS_BY_LENGTH.each do |keyword|
+        remaining_text = text[search_offset..]
+        keyword_position = find_top_level_keyword(remaining_text, keyword)
+        next unless keyword_position
+
+        absolute_position = search_offset + keyword_position
+        next if earliest_match && absolute_position >= earliest_match[:position]
+
+        earliest_match = {
+          position: absolute_position,
+          keyword: keyword,
+        }
+      end
+
+      earliest_match
+    end
+
     def scan_top_level_conjunctions(text)
       scanner = Scanner.new(text)
       conjunction_boundaries = []

data/lib/sql_beautifier/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql_beautifier
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Kinnell Shah