sql_beautifier 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cd89341ca715477774f461f2f819550e28aea5b10da268f4cb662079b6d6577
-  data.tar.gz: f9e1cb24ddfcae2290117366a969c14865cb938edb88574cd4e0fd5be1aee439
+  metadata.gz: d52933edcc70d3aaa5ed46f2c5d3bc6ac0a285294d84b25aa95c4e397fcb1d79
+  data.tar.gz: 5411d9f654c2d73fad75289e15433f47c34a45f463eae15fb1d832306fb62bd6
 SHA512:
-  metadata.gz: bd61f519fd40401a02d1a8a235a4c4957754f07a0c8862bbfccf464706c0417397c9284215c9c02dadfb21a38e7bd7dc36a0302abf1042fe2931adcf940ae859
-  data.tar.gz: d76dfa235ca58a94733582e52f991c4997dfe5dee336a8dc7adc4937fc89891c76de6e2bb6d06449c241bdcd416ecdb8f137b31fd9a6513cc490a478c890f8b5
+  metadata.gz: bbb3edc9cbe4e663ee167fda3632b12ffff04e5eddc6f225728abad772be643c7c6c97755ca4662210b380489ab5c2acf39968457fbc49042079e39eec5b120a
+  data.tar.gz: 5822d3514ad54619848b8e90cce8d5c4989cd2d367a20df00d51d3c03bf07a34b55166757ae72694970583a28db840a3234d7a309520673d2afc8e0d6a98e6f8

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [X.X.X] - YYYY-MM-DD
 
+## [0.2.0] - 2026-03-27
+
+- Add JOIN support (inner, left, right, full outer, cross) with formatted continuation lines
+- Add automatic table aliasing using initials (e.g. `users` → `u`, `active_storage_blobs` → `asb`)
+- Add PascalCase table name formatting (e.g. `users` → `Users`, `user_sessions` → `User_Sessions`)
+- Add `table.column` → `alias.column` replacement across full output
+- Add DISTINCT and DISTINCT ON support in SELECT clause
+- Add AND/OR condition formatting in WHERE and HAVING clauses with per-line indentation
+- Add parenthesized condition group handling (inline when short, expanded when long)
+
 ## [0.1.4] - 2026-03-26
 
 - Update `bin/ci` and `bin/release` to use new formatting functions

data/README.md

@@ -41,14 +41,149 @@ select  id,
         name,
         email
 
-from    users
+from    Users u
 
 where   active = true
 
 order by name
 ```
 
-Single-word keywords are lowercased and padded so their clause bodies start at an 8-character column. Multi-word clauses such as `order by` and `group by`, and short clauses like `limit`, use a single space between the keyword and the clause body instead of padding. Each clause is separated by a blank line. Multi-column SELECT lists place each column on its own line with continuation indentation.
+Single-word keywords are lowercased and padded so their clause bodies start at an 8-character column. Multi-word clauses such as `order by` and `group by`, and short clauses like `limit`, use a single space between the keyword and the clause body instead of padding. Each clause is separated by a blank line. Multi-column SELECT lists place each column on its own line with continuation indentation. Table names are PascalCased and automatically aliased.
+
+### Table Aliasing
+
+Tables are automatically aliased using their initials. Underscore-separated table names use the first letter of each segment:
+
+| Table Name | PascalCase | Alias |
+| --- | --- | --- |
+| `users` | `Users` | `u` |
+| `active_storage_blobs` | `Active_Storage_Blobs` | `asb` |
+| `person_event_invitations` | `Person_Event_Invitations` | `pei` |
+
+All `table.column` references throughout the query are replaced with `alias.column`:
+
+```ruby
+SqlBeautifier.call("SELECT users.id, users.name FROM users WHERE users.active = true")
+```
+
+Produces:
+
+```sql
+select  u.id,
+        u.name
+
+from    Users u
+
+where   u.active = true
+```
+
+When two tables produce the same initials, a counter is appended for disambiguation (e.g. `u1`, `u2`).
+
+### JOINs
+
+JOIN clauses are formatted on continuation-indented lines with PascalCase table names and aliases. Multi-condition JOINs place additional conditions on further-indented lines:
+
+```ruby
+SqlBeautifier.call(<<~SQL)
+  SELECT users.id, orders.total, products.name
+  FROM users
+  INNER JOIN orders ON orders.user_id = users.id
+  INNER JOIN products ON products.id = orders.product_id
+  WHERE users.active = true AND orders.total > 100
+  ORDER BY orders.total DESC
+SQL
+```
+
+Produces:
+
+```sql
+select  u.id,
+        o.total,
+        p.name
+
+from    Users u
+        inner join Orders o on o.user_id = u.id
+        inner join Products p on p.id = o.product_id
+
+where   u.active = true
+        and o.total > 100
+
+order by o.total desc
+```
+
+Supported join types: `inner join`, `left join`, `right join`, `full join`, `left outer join`, `right outer join`, `full outer join`, `cross join`.
+
+### DISTINCT and DISTINCT ON
+
+`DISTINCT` is placed on the `select` line as a modifier, with columns on continuation lines:
+
+```ruby
+SqlBeautifier.call("SELECT DISTINCT id, name, email FROM users")
+```
+
+Produces:
+
+```sql
+select  distinct
+        id,
+        name,
+        email
+
+from    Users u
+```
+
+`DISTINCT ON` preserves the full expression:
+
+```ruby
+SqlBeautifier.call("SELECT DISTINCT ON (user_id) id, name FROM events")
+```
+
+Produces:
+
+```sql
+select  distinct on (user_id)
+        id,
+        name
+
+from    Events e
+```
+
+### WHERE and HAVING Conditions
+
+Multiple conditions in WHERE and HAVING clauses are formatted with each condition on its own line:
+
+```ruby
+SqlBeautifier.call("SELECT * FROM users WHERE active = true AND role = 'admin' AND created_at > '2024-01-01'")
+```
+
+Produces:
+
+```sql
+select  *
+
+from    Users u
+
+where   active = true
+        and role = 'admin'
+        and created_at > '2024-01-01'
+```
+
+Short parenthesized groups stay inline:
+
+```ruby
+SqlBeautifier.call("SELECT * FROM users WHERE active = true AND (role = 'admin' OR role = 'moderator')")
+```
+
+Produces:
+
+```sql
+select  *
+
+from    Users u
+
+where   active = true
+        and (role = 'admin' or role = 'moderator')
+```
 
 ### GROUP BY and HAVING
 
@@ -67,7 +202,7 @@ Produces:
 select  status,
         count(*)
 
-from    users
+from    Users u
 
 group by status
 
@@ -85,7 +220,7 @@ Produces:
 ```sql
 select  id
 
-from    users
+from    Users u
 
 order by created_at desc
 
@@ -105,9 +240,10 @@ Produces:
 ```sql
 select  *
 
-from    users
+from    Users u
 
-where   name = 'O''Brien' and status = 'Active'
+where   name = 'O''Brien'
+        and status = 'Active'
 ```
 
 ### Double-Quoted Identifiers
@@ -124,7 +260,7 @@ Produces:
 select  user_id,
         full_name
 
-from    users
+from    Users u
 ```
 
 ### Callable Interface

data/lib/sql_beautifier/clauses/condition_clause.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module Clauses
+    class ConditionClause < Base
+      def call
+        return "#{self.class::KEYWORD_PREFIX}#{@value.strip}" unless multiple_conditions?
+
+        formatted_conditions = ConditionFormatter.format(@value, indent_width: Constants::KEYWORD_COLUMN_WIDTH)
+        formatted_conditions.sub(Constants::LEADING_KEYWORD_INDENT_PATTERN, self.class::KEYWORD_PREFIX)
+      end
+
+      private
+
+      def multiple_conditions?
+        Tokenizer.split_top_level_conditions(@value).length > 1
+      end
+    end
+  end
+end

data/lib/sql_beautifier/clauses/from.rb

@@ -4,9 +4,144 @@ module SqlBeautifier
   module Clauses
     class From < Base
       KEYWORD_PREFIX = "from    "
+      CONTINUATION_INDENTATION = "        "
+      JOIN_CONDITION_INDENTATION = "            "
+
+      def self.call(value, table_registry:)
+        new(value, table_registry: table_registry).call
+      end
+
+      def initialize(value, table_registry:)
+        super(value)
+        @table_registry = table_registry
+      end
 
       def call
-        "#{KEYWORD_PREFIX}#{@value.strip}"
+        @lines = []
+
+        join_parts = split_join_parts
+        primary_table_text = join_parts.shift.strip
+        formatted_primary_table_name = format_table_with_alias(primary_table_text)
+        add_line!("#{KEYWORD_PREFIX}#{formatted_primary_table_name}")
+
+        join_parts.each { |join_part| format_join_part(join_part) }
+
+        @lines.join("\n")
+      end
+
+      private
+
+      def add_line!(line)
+        @lines << line
+      end
+
+      def format_join_part(join_part)
+        join_keyword, remaining_join_content = extract_join_keyword(join_part)
+        return unless join_keyword && remaining_join_content
+
+        on_keyword_position = Tokenizer.find_top_level_keyword(remaining_join_content, "on")
+
+        if on_keyword_position
+          format_join_with_conditions(join_keyword, remaining_join_content, on_keyword_position)
+        else
+          formatted_table_name = format_table_with_alias(remaining_join_content)
+          add_line!("#{CONTINUATION_INDENTATION}#{join_keyword} #{formatted_table_name}")
+        end
+      end
+
+      def format_join_with_conditions(join_keyword, join_content, on_keyword_position)
+        table_text = join_content[0...on_keyword_position].strip
+        condition_text = join_content[on_keyword_position..].delete_prefix("on").strip
+        on_conditions = Tokenizer.split_top_level_conditions(condition_text)
+
+        formatted_table_name = format_table_with_alias(table_text)
+        first_condition = on_conditions.first[1]
+        add_line!("#{CONTINUATION_INDENTATION}#{join_keyword} #{formatted_table_name} on #{first_condition}")
+
+        on_conditions.drop(1).each do |conjunction, additional_condition|
+          add_line!("#{JOIN_CONDITION_INDENTATION}#{conjunction} #{additional_condition}")
+        end
+      end
+
+      def split_join_parts
+        from_content = @value.strip
+        join_keyword_positions = find_all_join_keyword_positions(from_content)
+
+        return [from_content] if join_keyword_positions.empty?
+
+        parts = [from_content[0...join_keyword_positions.first[:position]]]
+
+        join_keyword_positions.each_with_index do |join_info, index|
+          end_position = begin
+            if index + 1 < join_keyword_positions.length
+              join_keyword_positions[index + 1][:position]
+            else
+              from_content.length
+            end
+          end
+
+          parts << from_content[join_info[:position]...end_position]
+        end
+
+        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
+
+      def extract_join_keyword(join_part)
+        trimmed_join_text = join_part.strip
+
+        Constants::JOIN_KEYWORDS_BY_LENGTH.each do |keyword|
+          next unless trimmed_join_text.downcase.start_with?(keyword)
+
+          remaining_join_content = trimmed_join_text[keyword.length..].strip
+
+          return [keyword, remaining_join_content]
+        end
+
+        [nil, nil]
+      end
+
+      def format_table_with_alias(table_text)
+        table_name = Util.first_word(table_text)
+        formatted_table_name = Util.upper_pascal_case(table_name)
+        table_alias = @table_registry.alias_for(table_name)
+        return formatted_table_name unless table_alias
+
+        "#{formatted_table_name} #{table_alias}"
       end
     end
   end

data/lib/sql_beautifier/clauses/having.rb

@@ -2,12 +2,8 @@
 
 module SqlBeautifier
   module Clauses
-    class Having < Base
+    class Having < ConditionClause
       KEYWORD_PREFIX = "having  "
-
-      def call
-        "#{KEYWORD_PREFIX}#{@value.strip}"
-      end
     end
   end
 end

data/lib/sql_beautifier/clauses/select.rb

@@ -4,17 +4,72 @@ module SqlBeautifier
   module Clauses
     class Select < Base
       KEYWORD_PREFIX = "select  "
-      CONTINUATION_INDENT = "        "
+      CONTINUATION_INDENTATION = "        "
+      DISTINCT_ON_PARENTHESIS_PATTERN = %r{distinct on\s*\(}
+      DISTINCT_ON_PATTERN = %r{distinct on }
+      LEADING_COMMA_PATTERN = %r{\A,\s*}
 
       def call
-        columns = Tokenizer.split_by_top_level_commas(@value)
-        return "#{KEYWORD_PREFIX}#{columns.first.strip}" if columns.length == 1
+        prefix, remaining_columns = extract_prefix
+        columns = Tokenizer.split_by_top_level_commas(remaining_columns)
 
-        column_lines = columns.map { |column| "#{CONTINUATION_INDENT}#{column.strip}" }
-        column_lines[0] = "#{KEYWORD_PREFIX}#{columns.first.strip}"
+        return format_with_prefix(prefix, columns) if prefix
+        return keyword_line(columns.first) if columns.length == 1
+
+        format_columns_list(columns)
+      end
+
+      private
+
+      def keyword_line(column)
+        "#{KEYWORD_PREFIX}#{column.strip}"
+      end
+
+      def continuation_line(column)
+        "#{CONTINUATION_INDENTATION}#{column.strip}"
+      end
+
+      def format_with_prefix(prefix, columns)
+        first_line = "#{KEYWORD_PREFIX}#{prefix}"
+        column_lines = columns.map { |column| continuation_line(column) }
+
+        "#{first_line}\n#{column_lines.join(",\n")}"
+      end
+
+      def format_columns_list(columns)
+        column_lines = columns.map { |column| continuation_line(column) }
+        column_lines[0] = keyword_line(columns.first)
 
         column_lines.join(",\n")
       end
+
+      def extract_prefix
+        stripped_value = @value.strip
+
+        if stripped_value.start_with?("distinct on ")
+          extract_distinct_on_prefix(stripped_value)
+        elsif stripped_value.start_with?("distinct ")
+          remaining_columns = stripped_value.delete_prefix("distinct ").strip
+
+          ["distinct", remaining_columns]
+        else
+          [nil, stripped_value]
+        end
+      end
+
+      def extract_distinct_on_prefix(stripped_value)
+        distinct_on_position = stripped_value.index(DISTINCT_ON_PARENTHESIS_PATTERN) || stripped_value.index(DISTINCT_ON_PATTERN)
+        opening_parenthesis_position = stripped_value.index(Constants::OPEN_PARENTHESIS, distinct_on_position)
+        return [nil, stripped_value] unless opening_parenthesis_position
+
+        closing_parenthesis_position = Tokenizer.find_matching_parenthesis(stripped_value, opening_parenthesis_position)
+        return [nil, stripped_value] unless closing_parenthesis_position
+
+        prefix = stripped_value[0..closing_parenthesis_position]
+        remaining_columns = stripped_value[(closing_parenthesis_position + 1)..].strip.sub(LEADING_COMMA_PATTERN, "")
+
+        [prefix, remaining_columns]
+      end
     end
   end
 end

data/lib/sql_beautifier/clauses/where.rb

@@ -2,12 +2,8 @@
 
 module SqlBeautifier
   module Clauses
-    class Where < Base
+    class Where < ConditionClause
       KEYWORD_PREFIX = "where   "
-
-      def call
-        "#{KEYWORD_PREFIX}#{@value.strip}"
-      end
     end
   end
 end

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 = " " * 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 <= Constants::INLINE_GROUP_THRESHOLD
+
+      inner_content = Util.strip_outer_parentheses(condition_text.strip)
+      formatted_inner_content = format(inner_content, indent_width: indent_width + 4)
+      indentation = " " * 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/constants.rb

@@ -11,5 +11,37 @@ 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"
+
+    INLINE_GROUP_THRESHOLD = 100
+    KEYWORD_COLUMN_WIDTH = 8
+
+    LEADING_KEYWORD_INDENT_PATTERN = %r{\A#{' ' * KEYWORD_COLUMN_WIDTH}}
+
+    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

@@ -20,10 +20,11 @@ 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)
@@ -33,6 +34,7 @@ module SqlBeautifier
       output = @parts.join("\n\n")
       return "#{@normalized_value}\n" if output.empty?
 
+      output = @table_registry.apply_aliases(output) if @table_registry
       "#{output}\n"
     end
 
@@ -44,5 +46,12 @@ 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
   end
 end