sql_beautifier 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d52933edcc70d3aaa5ed46f2c5d3bc6ac0a285294d84b25aa95c4e397fcb1d79
-  data.tar.gz: 5411d9f654c2d73fad75289e15433f47c34a45f463eae15fb1d832306fb62bd6
+  metadata.gz: 928801124a1241f4b12dc2e7e7966cd95dcba5754cc6ee88a08c9f641f2e32e4
+  data.tar.gz: eb1db005fb6923f5f99aaacc44caeeed14b6c7f6e4d8cd174fb3fcff92cf944e
 SHA512:
-  metadata.gz: bbb3edc9cbe4e663ee167fda3632b12ffff04e5eddc6f225728abad772be643c7c6c97755ca4662210b380489ab5c2acf39968457fbc49042079e39eec5b120a
-  data.tar.gz: 5822d3514ad54619848b8e90cce8d5c4989cd2d367a20df00d51d3c03bf07a34b55166757ae72694970583a28db840a3234d7a309520673d2afc8e0d6a98e6f8
+  metadata.gz: c0ee8ca9569e7409f989cce52070112bb61af2c064dec679a96e7f26bb74837b8f2ae207617f619280140548fb5cc8804a1996464265415efc96d0e0fafc7085
+  data.tar.gz: b1cff6570a5137fd7ff26fd11eed662d7002c9d242ca03ea303c0c1711f4a44f12dbdc3958ce3657b0988742abd351792476ab0fc7171ccafebe1c28a70be595

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [X.X.X] - YYYY-MM-DD
 
+## [0.4.0] - 2026-03-27
+
+## [0.3.0] - 2026-03-27
+
+- Add configuration system with `SqlBeautifier.configure` block and `SqlBeautifier.reset_configuration!`
+- Add configurable keyword case (`:lower` / `:upper`), keyword column width, indent spaces, table name format (`:pascal_case` / `:lowercase`), inline group threshold, and alias strategy (`:initials` / `:none` / callable)
+- Add semicolon stripping in normalizer (trailing `;` removed before formatting)
+- Add comment stripping in normalizer (`--` line comments and `/* */` block comments, string-aware)
+- Add subquery formatting with recursive indentation (`(select ...)` expanded to multiline)
+
 ## [0.2.0] - 2026-03-27
 
 - Add JOIN support (inner, left, right, full outer, cross) with formatted continuation lines

data/README.md

@@ -48,16 +48,16 @@ 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. Table names are PascalCased and automatically aliased.
+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. Clause spacing is compact by default for simple one-column / one-table / one-condition queries, and otherwise uses blank lines between top-level clauses. 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` |
+| 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`:
@@ -219,11 +219,8 @@ Produces:
 
 ```sql
 select  id
-
 from    Users u
-
 order by created_at desc
-
 limit 25
 ```
 
@@ -263,6 +260,87 @@ select  user_id,
 from    Users u
 ```
 
+### Subqueries
+
+Subqueries are automatically detected and recursively formatted with indentation:
+
+```ruby
+SqlBeautifier.call("SELECT id FROM users WHERE id IN (SELECT user_id FROM orders WHERE total > 100)")
+```
+
+Produces:
+
+```sql
+select  id
+from    Users u
+where   id in (
+            select  user_id
+            from    Orders o
+            where   total > 100
+        )
+```
+
+Nested subqueries increase indentation at each level.
+
+### Comments and Semicolons
+
+SQL comments (`--` line comments and `/* */` block comments) and trailing semicolons are automatically stripped during normalization. Comments inside string literals are preserved:
+
+```ruby
+SqlBeautifier.call("SELECT id /* primary key */ FROM users -- main table\nWHERE active = true;")
+```
+
+Produces:
+
+```sql
+select  id
+from    Users u
+where   active = true
+```
+
+### Configuration
+
+Customize formatting behavior with `SqlBeautifier.configure`:
+
+```ruby
+SqlBeautifier.configure do |config|
+  config.keyword_case = :upper           # :lower (default), :upper
+  config.keyword_column_width = 10       # default: 8
+  config.indent_spaces = 4               # default: 4
+  config.clause_spacing_mode = :spacious # :compact (default), :spacious
+  config.table_name_format = :lowercase  # :pascal_case (default), :lowercase
+  config.inline_group_threshold = 80     # default: 100
+  config.alias_strategy = :none          # :initials (default), :none, or a callable
+end
+```
+
+#### Clause Spacing Modes
+
+- `:compact` (default) keeps top-level clauses on single newlines only when the query is simple:
+  - exactly one SELECT column
+  - exactly one FROM table (no JOINs)
+  - zero or one top-level WHERE condition
+  - only `select`, `from`, optional `where`, optional `order by`, and optional `limit`
+- `:spacious` always separates top-level clauses with blank lines
+
+Reset to defaults:
+
+```ruby
+SqlBeautifier.reset_configuration!
+```
+
+#### Alias Strategies
+
+- `:initials` (default) — automatic aliases using table initials (`users` → `u`, `active_storage_blobs` → `asb`)
+- `:none` — no automatic aliases (explicit aliases in the SQL are still preserved)
+- Callable — provide a proc/lambda for custom alias generation:
+
+```ruby
+SqlBeautifier.configure do |config|
+  config.alias_strategy = ->(table_name) { "t_#{table_name[0..2]}" }
+end
+```
+
 ### Callable Interface
 
 `SqlBeautifier.call` is the public API, making it a valid callable for Rails `normalizes` and anywhere a proc-like object is expected:

data/lib/sql_beautifier/clauses/base.rb

@@ -10,6 +10,16 @@ module SqlBeautifier
       def initialize(value)
         @value = value
       end
+
+      private
+
+      def keyword_prefix
+        Util.keyword_padding(self.class::KEYWORD)
+      end
+
+      def continuation_indent
+        Util.continuation_padding
+      end
     end
   end
 end

data/lib/sql_beautifier/clauses/condition_clause.rb

@@ -4,10 +4,10 @@ module SqlBeautifier
   module Clauses
     class ConditionClause < Base
       def call
-        return "#{self.class::KEYWORD_PREFIX}#{@value.strip}" unless multiple_conditions?
+        return "#{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)
+        formatted_conditions = ConditionFormatter.format(@value, indent_width: SqlBeautifier.config_for(:keyword_column_width))
+        formatted_conditions.sub(continuation_indent, keyword_prefix)
       end
 
       private

data/lib/sql_beautifier/clauses/from.rb

@@ -3,9 +3,7 @@
 module SqlBeautifier
   module Clauses
     class From < Base
-      KEYWORD_PREFIX = "from    "
-      CONTINUATION_INDENTATION = "        "
-      JOIN_CONDITION_INDENTATION = "            "
+      KEYWORD = "from"
 
       def self.call(value, table_registry:)
         new(value, table_registry: table_registry).call
@@ -22,7 +20,7 @@ module SqlBeautifier
         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}")
+        add_line!("#{keyword_prefix}#{formatted_primary_table_name}")
 
         join_parts.each { |join_part| format_join_part(join_part) }
 
@@ -35,6 +33,10 @@ module SqlBeautifier
         @lines << line
       end
 
+      def join_condition_indentation
+        Util.whitespace(SqlBeautifier.config_for(:keyword_column_width) + 4)
+      end
+
       def format_join_part(join_part)
         join_keyword, remaining_join_content = extract_join_keyword(join_part)
         return unless join_keyword && remaining_join_content
@@ -45,7 +47,7 @@ module SqlBeautifier
           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}")
+          add_line!("#{continuation_indent}#{join_keyword} #{formatted_table_name}")
         end
       end
 
@@ -56,10 +58,10 @@ module SqlBeautifier
 
         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}")
+        add_line!("#{continuation_indent}#{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}")
+          add_line!("#{join_condition_indentation}#{conjunction} #{additional_condition}")
         end
       end
 
@@ -137,7 +139,7 @@ module SqlBeautifier
 
       def format_table_with_alias(table_text)
         table_name = Util.first_word(table_text)
-        formatted_table_name = Util.upper_pascal_case(table_name)
+        formatted_table_name = Util.format_table_name(table_name)
         table_alias = @table_registry.alias_for(table_name)
         return formatted_table_name unless table_alias
 

data/lib/sql_beautifier/clauses/group_by.rb

@@ -3,10 +3,10 @@
 module SqlBeautifier
   module Clauses
     class GroupBy < Base
-      KEYWORD_PREFIX = "group by "
+      KEYWORD = "group by"
 
       def call
-        "#{KEYWORD_PREFIX}#{@value.strip}"
+        "#{keyword_prefix}#{@value.strip}"
       end
     end
   end

data/lib/sql_beautifier/clauses/having.rb

@@ -3,7 +3,7 @@
 module SqlBeautifier
   module Clauses
     class Having < ConditionClause
-      KEYWORD_PREFIX = "having  "
+      KEYWORD = "having"
     end
   end
 end

data/lib/sql_beautifier/clauses/limit.rb

@@ -3,10 +3,16 @@
 module SqlBeautifier
   module Clauses
     class Limit < Base
-      KEYWORD_PREFIX = "limit "
+      KEYWORD = "limit"
 
       def call
-        "#{KEYWORD_PREFIX}#{@value.strip}"
+        "#{keyword_prefix}#{@value.strip}"
+      end
+
+      private
+
+      def keyword_prefix
+        "#{Util.format_keyword(KEYWORD)} "
       end
     end
   end

data/lib/sql_beautifier/clauses/order_by.rb

@@ -3,10 +3,10 @@
 module SqlBeautifier
   module Clauses
     class OrderBy < Base
-      KEYWORD_PREFIX = "order by "
+      KEYWORD = "order by"
 
       def call
-        "#{KEYWORD_PREFIX}#{@value.strip}"
+        "#{keyword_prefix}#{@value.strip}"
       end
     end
   end

data/lib/sql_beautifier/clauses/select.rb

@@ -3,8 +3,7 @@
 module SqlBeautifier
   module Clauses
     class Select < Base
-      KEYWORD_PREFIX = "select  "
-      CONTINUATION_INDENTATION = "        "
+      KEYWORD = "select"
       DISTINCT_ON_PARENTHESIS_PATTERN = %r{distinct on\s*\(}
       DISTINCT_ON_PATTERN = %r{distinct on }
       LEADING_COMMA_PATTERN = %r{\A,\s*}
@@ -22,15 +21,15 @@ module SqlBeautifier
       private
 
       def keyword_line(column)
-        "#{KEYWORD_PREFIX}#{column.strip}"
+        "#{keyword_prefix}#{column.strip}"
       end
 
       def continuation_line(column)
-        "#{CONTINUATION_INDENTATION}#{column.strip}"
+        "#{continuation_indent}#{column.strip}"
       end
 
       def format_with_prefix(prefix, columns)
-        first_line = "#{KEYWORD_PREFIX}#{prefix}"
+        first_line = "#{keyword_prefix}#{prefix}"
         column_lines = columns.map { |column| continuation_line(column) }
 
         "#{first_line}\n#{column_lines.join(",\n")}"

data/lib/sql_beautifier/clauses/where.rb

@@ -3,7 +3,7 @@
 module SqlBeautifier
   module Clauses
     class Where < ConditionClause
-      KEYWORD_PREFIX = "where   "
+      KEYWORD = "where"
     end
   end
 end

data/lib/sql_beautifier/condition_formatter.rb

@@ -9,7 +9,7 @@ module SqlBeautifier
       return text.strip if conditions.length <= 1 && !parse_condition_group(conditions.dig(0, 1))
 
       conditions = flatten_same_conjunction_groups(conditions)
-      indentation = " " * indent_width
+      indentation = Util.whitespace(indent_width)
       lines = []
 
       conditions.each_with_index do |(conjunction, condition_text), index|
@@ -92,11 +92,11 @@ module SqlBeautifier
       return condition_text unless inner_conditions
 
       inline_version = rebuild_inline(inner_conditions)
-      return inline_version if inline_version.length <= Constants::INLINE_GROUP_THRESHOLD
+      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 = " " * indent_width
+      indentation = Util.whitespace(indent_width)
 
       "(\n#{formatted_inner_content}\n#{indentation})"
     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

@@ -29,11 +29,6 @@ module SqlBeautifier
     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 = ","

data/lib/sql_beautifier/cte_formatter.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module CteFormatter
+    module_function
+
+    def format(normalized_sql, depth: 0)
+      return nil unless cte_query?(normalized_sql)
+
+      recursive, definitions, main_query_sql = parse(normalized_sql)
+      return nil unless definitions.any? && main_query_sql.present?
+
+      format_cte_statement(recursive, definitions, main_query_sql, depth)
+    end
+
+    def cte_query?(sql)
+      Tokenizer.keyword_at?(sql, 0, "with")
+    end
+
+    def parse(sql)
+      position = skip_past_keyword(sql, 0, "with")
+
+      recursive = Tokenizer.keyword_at?(sql, position, "recursive")
+      position = skip_past_keyword(sql, position, "recursive") if recursive
+
+      definitions = []
+
+      loop do
+        definition, new_position = parse_definition(sql, position)
+        break unless definition
+
+        definitions << definition
+        position = skip_whitespace(sql, new_position)
+
+        break unless position < sql.length && sql[position] == Constants::COMMA
+
+        position = skip_whitespace(sql, position + 1)
+      end
+
+      main_query_sql = sql[position..].strip
+
+      [recursive, definitions, main_query_sql]
+    end
+
+    def parse_definition(sql, position)
+      name, position = read_identifier(sql, position)
+      return nil unless name
+
+      position = skip_whitespace(sql, position)
+
+      column_list = parse_column_list(sql, position)
+      position = column_list[:next_position] if column_list
+
+      return nil unless Tokenizer.keyword_at?(sql, position, "as")
+
+      position = skip_past_keyword(sql, position, "as")
+      materialization, position = parse_materialization(sql, position)
+
+      return nil unless position < sql.length && sql[position] == Constants::OPEN_PARENTHESIS
+
+      closing = Tokenizer.find_matching_parenthesis(sql, position)
+      return nil unless closing
+
+      body_sql = sql[(position + 1)...closing].strip
+      definition = { name: name, body: body_sql }
+      definition[:column_list] = column_list[:text] if column_list
+      definition[:materialization] = materialization if materialization
+
+      [definition, closing + 1]
+    end
+
+    def parse_column_list(sql, position)
+      return nil unless position < sql.length && sql[position] == Constants::OPEN_PARENTHESIS
+
+      closing = Tokenizer.find_matching_parenthesis(sql, position)
+      return nil unless closing
+
+      after_paren = skip_whitespace(sql, closing + 1)
+      return nil unless Tokenizer.keyword_at?(sql, after_paren, "as")
+
+      { text: sql[(position + 1)...closing].strip, next_position: after_paren }
+    end
+
+    def format_cte_statement(recursive, definitions, main_query_sql, depth)
+      keyword_width = SqlBeautifier.config_for(:keyword_column_width)
+      cte_name_column = keyword_width
+      continuation_indent = Util.continuation_padding
+
+      output = +""
+
+      definitions.each_with_index do |definition, index|
+        if index.zero?
+          output << Util.keyword_padding("with")
+          output << "#{Util.format_keyword('recursive')} " if recursive
+        else
+          output << continuation_indent
+        end
+
+        output << definition_header(definition)
+        output << format_body(definition[:body], cte_name_column)
+        output << (index < definitions.length - 1 ? ",\n" : "\n\n")
+      end
+
+      formatted_main = Formatter.new(main_query_sql, depth: depth).call
+      output << formatted_main if formatted_main
+
+      output
+    end
+
+    def definition_header(definition)
+      header = +definition[:name].to_s
+      header << " (#{definition[:column_list]})" if definition[:column_list]
+      header << " #{Util.format_keyword('as')}"
+      header << " #{format_materialization(definition[:materialization])}" if definition[:materialization]
+      header << " "
+      header
+    end
+
+    def parse_materialization(sql, position)
+      position = skip_whitespace(sql, position)
+      return ["materialized", skip_past_keyword(sql, position, "materialized")] if Tokenizer.keyword_at?(sql, position, "materialized")
+      return [nil, position] unless Tokenizer.keyword_at?(sql, position, "not")
+
+      materialized_position = skip_past_keyword(sql, position, "not")
+      return [nil, position] unless Tokenizer.keyword_at?(sql, materialized_position, "materialized")
+
+      ["not materialized", skip_past_keyword(sql, materialized_position, "materialized")]
+    end
+
+    def format_materialization(materialization)
+      return Util.format_keyword("materialized") if materialization == "materialized"
+
+      [Util.format_keyword("not"), Util.format_keyword("materialized")].join(" ")
+    end
+
+    def format_body(body_sql, base_indent)
+      indent_spaces = SqlBeautifier.config_for(:indent_spaces) || 4
+      body_indent = base_indent + indent_spaces
+      formatted = Formatter.new(body_sql, depth: 0).call
+      return "(#{body_sql})" unless formatted
+
+      indentation = Util.whitespace(body_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 read_identifier(sql, position)
+      position = skip_whitespace(sql, position)
+      return nil if position >= sql.length
+
+      if sql[position] == Constants::DOUBLE_QUOTE
+        start = position
+        position += 1
+
+        while position < sql.length
+          if sql[position] == Constants::DOUBLE_QUOTE
+            if position + 1 < sql.length && sql[position + 1] == Constants::DOUBLE_QUOTE
+              position += 2
+              next
+            end
+
+            position += 1
+            break
+          end
+
+          position += 1
+        end
+
+        return nil unless position <= sql.length && sql[position - 1] == Constants::DOUBLE_QUOTE
+
+        return [sql[start...position], position]
+      end
+
+      start = position
+      position += 1 while position < sql.length && sql[position] =~ Tokenizer::IDENTIFIER_CHARACTER
+      return nil if position == start
+
+      [sql[start...position], position]
+    end
+
+    def skip_whitespace(sql, position)
+      position += 1 while position < sql.length && sql[position] =~ Constants::WHITESPACE_CHARACTER_REGEX
+      position
+    end
+
+    def skip_past_keyword(sql, position, keyword)
+      skip_whitespace(sql, position + keyword.length)
+    end
+  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
@@ -16,6 +17,9 @@ module SqlBeautifier
       @normalized_value = Normalizer.call(@value)
       return unless @normalized_value.present?
 
+      cte_result = CteFormatter.format(@normalized_value, depth: @depth)
+      return cte_result if cte_result
+
       first_clause_position = Tokenizer.first_clause_position(@normalized_value)
       return "#{@normalized_value}\n" if first_clause_position.nil? || first_clause_position.positive?
 
@@ -31,9 +35,10 @@ module SqlBeautifier
       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
@@ -53,5 +58,48 @@ module SqlBeautifier
 
       @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,6 +18,11 @@ 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
 
@@ -110,5 +115,71 @@ module SqlBeautifier
     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

data/lib/sql_beautifier/table_registry.rb

@@ -7,6 +7,7 @@ module SqlBeautifier
     def initialize(from_content)
       @from_content = from_content
       @table_map = {}
+      @alias_strategy = SqlBeautifier.config_for(:alias_strategy)
       build!
     end
 
@@ -15,6 +16,8 @@ module SqlBeautifier
     end
 
     def apply_aliases(text)
+      return text if @table_map.empty?
+
       output = +""
       position = 0
 
@@ -48,10 +51,19 @@ module SqlBeautifier
 
     def build!
       table_entries = extract_table_entries(@from_content)
-      initials_occurrence_counts = count_initials_occurrences(table_entries)
-      used_aliases = []
 
-      assign_aliases!(table_entries, initials_occurrence_counts, used_aliases)
+      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
 
@@ -163,6 +175,8 @@ module SqlBeautifier
     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
 

data/lib/sql_beautifier/util.rb

@@ -4,6 +4,10 @@ module SqlBeautifier
   module Util
     module_function
 
+    def whitespace(length)
+      " " * length
+    end
+
     def upper_pascal_case(name)
       name.split("_").map(&:capitalize).join("_")
     end
@@ -30,5 +34,34 @@ module SqlBeautifier
 
       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.2.0"
+  VERSION = "0.4.0"
 end

data/lib/sql_beautifier.rb

@@ -5,11 +5,14 @@ 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/cte_formatter"
 require_relative "sql_beautifier/clauses/base"
 require_relative "sql_beautifier/clauses/condition_clause"
 require_relative "sql_beautifier/clauses/select"
@@ -31,4 +34,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.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kinnell Shah
@@ -47,9 +47,12 @@ files:
 - 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/cte_formatter.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