sql_beautifier 0.10.3 → 0.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35c33bf6ef1f1c6095643a9e6661aa16a93a29ff44534aab07fddd0befec5b43
-  data.tar.gz: aab36afe287416dc61b4633f3d4c07975736d6111a427118bf975be2742325a6
+  metadata.gz: 7c92d6b96851b3e1d24b983a6cf8d3d01ee643f4418d7c66cdc92bdc32baa132
+  data.tar.gz: 8cf024876d629ff3a2beaae6604c4cc860a6652582b90bf1f3c6c4001acc3517
 SHA512:
-  metadata.gz: 58f7b763cc122816a919b2caa1ba0281efb5fa8dc1bfbd4e97f27c6838728e8a8db2a6018d819d1f2314359851f1cd138f28bb0f0fb21986defa4a1e11ad724a
-  data.tar.gz: db2e7de085a689a9331e831432f5ed31f8a58304c9f20f4cca2376acf68681da9ba84741c18bf0fb9b9002c85fb4f1d87c3e8bf92fdf31a384455caba9cccb23
+  metadata.gz: 0252dddc816463054f4bcd225485cadb58eac11d964f6fd1f18e1d5fa3b23c2619caa0dc38d8f3395f7616fcf5e0e7d5d52e60bfca4f7d96b83fbfec7d345f19
+  data.tar.gz: 6dfa3284884d2c4df58d93dab99b31dcebce6e07f00a71d499a71bd37f0030a680f905ca15565b23e97f860b53a108feb23d5a3d004e2967c328eace9ff51bfe

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [X.X.X] - YYYY-MM-DD
 
+## [0.10.4] - 2026-03-30
+
+- Add `IN` list multiline formatting — `WHERE x IN (1, 2, 3)` value lists with 2+ items are now expanded to one item per line with proper indentation; single-item lists and `IN (SELECT ...)` subqueries are left unchanged
+- Fix redundant parentheses after `NOT` not being stripped — `NOT ((a = 1 OR b = 2))` is now reduced to `NOT (a = 1 OR b = 2)`, removing unnecessary doubled parentheses while preserving semantically required grouping
+
 ## [0.10.3] - 2026-03-30
 
 - Add `DROP TABLE` formatting — `DROP TABLE [IF EXISTS] table_name` statements are now recognized and rendered with proper keyword casing and PascalCase table names instead of passing through as normalized text

data/README.md

@@ -188,6 +188,41 @@ where   active = true
         );
 ```
 
+`IN` value lists with multiple items are expanded to one item per line. Single-item lists and `IN (SELECT ...)` subqueries are left inline:
+
+```ruby
+SqlBeautifier.call("SELECT id FROM users WHERE status IN ('active', 'pending', 'banned')")
+```
+
+Produces:
+
+```sql
+select  id
+from    Users u
+where   status in (
+            'active',
+            'pending',
+            'banned'
+        );
+```
+
+Redundant parentheses are removed, including after `NOT`:
+
+```ruby
+SqlBeautifier.call("SELECT id FROM users WHERE NOT ((active = true OR role = 'guest')) AND verified = true")
+```
+
+Produces:
+
+```sql
+select  id
+
+from    Users u
+
+where   not (active = true or role = 'guest')
+        and verified = true;
+```
+
 ### GROUP BY and HAVING
 
 ```ruby

data/lib/sql_beautifier/clauses/condition_clause.rb

@@ -7,8 +7,12 @@ module SqlBeautifier
         keyword_width = SqlBeautifier.config_for(:keyword_column_width)
         formatted_value = CaseExpression.format_in_text(@value, base_indent: keyword_width)
         unwrapped_value = strip_wrapping_parentheses(formatted_value)
+        unwrapped_value = Condition.unwrap_not_prefix_parens(unwrapped_value)
 
-        return "#{keyword_prefix}#{unwrapped_value}" unless multiple_conditions?(unwrapped_value)
+        unless multiple_conditions?(unwrapped_value)
+          formatted_leaf = InList.format_in_text(unwrapped_value, base_indent: keyword_width)
+          return "#{keyword_prefix}#{formatted_leaf}"
+        end
 
         formatted_conditions = Condition.format(unwrapped_value, indent_width: keyword_width)
         formatted_conditions.sub(continuation_indent, keyword_prefix)

data/lib/sql_beautifier/condition.rb

@@ -2,6 +2,8 @@
 
 module SqlBeautifier
   class Condition < Base
+    NOT_PREFIX_PATTERN = %r{\Anot([[:space:]]+)}i
+
     option :conjunction, default: -> {}
     option :expression, default: -> {}
     option :children, default: -> {}
@@ -52,7 +54,7 @@ module SqlBeautifier
     end
 
     def render(indent_width:)
-      return @expression if leaf?
+      return InList.format_in_text(@expression, base_indent: indent_width) if leaf?
 
       inline_version = render_inline
       return inline_version if inline_version.length <= SqlBeautifier.config_for(:inline_group_threshold)
@@ -89,7 +91,28 @@ module SqlBeautifier
         output = inner_content
       end
 
-      output
+      unwrap_not_prefix_parens(output)
+    end
+
+    def self.unwrap_not_prefix_parens(text)
+      prefix_match = text.match(NOT_PREFIX_PATTERN)
+      return text unless prefix_match
+
+      remainder = text[prefix_match[0].length..]
+
+      unwrapped_remainder = remainder
+
+      while Tokenizer.outer_parentheses_wrap_all?(unwrapped_remainder)
+        inner_content = Util.strip_outer_parentheses(unwrapped_remainder)
+        inner_conditions = Tokenizer.split_top_level_conditions(inner_content)
+        break if inner_conditions.length > 1
+
+        unwrapped_remainder = inner_content
+      end
+
+      return text if unwrapped_remainder == remainder
+
+      "not #{unwrapped_remainder}"
     end
 
     def self.parse_condition_group(condition_text)

data/lib/sql_beautifier/dml_rendering.rb

@@ -10,7 +10,8 @@ module SqlBeautifier
 
       formatted_where_text = begin
         if conditions.length <= 1 && conditions.first&.leaf?
-          "\n#{Util.keyword_padding('where')}#{@where_clause.strip}"
+          formatted_expression = InList.format_in_text(conditions.first.expression, base_indent: keyword_column_width)
+          "\n#{Util.keyword_padding('where')}#{formatted_expression}"
         else
           formatted_conditions = Condition.render_all(conditions, indent_width: keyword_column_width)
           "\n#{formatted_conditions.sub(Util.continuation_padding, Util.keyword_padding('where'))}"

data/lib/sql_beautifier/in_list.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module SqlBeautifier
+  module InList
+    IN_KEYWORD = "in"
+    NOT_IN_KEYWORD = "not in"
+    SUBQUERY_PATTERN = %r{\A[[:space:]]*select(?:[[:space:]]|\()}i
+
+    module_function
+
+    def format_in_text(text, base_indent: 0)
+      output = +""
+      scanner = Scanner.new(text)
+
+      while scanner.position < text.length
+        consumed = scanner.scan_quoted_or_sentinel!
+        if consumed
+          output << consumed
+          next
+        end
+
+        if scanner.current_char == Constants::OPEN_PARENTHESIS
+          scanner.increment_depth!
+          output << scanner.current_char
+          scanner.advance!
+          next
+        end
+
+        if scanner.current_char == Constants::CLOSE_PARENTHESIS
+          scanner.decrement_depth!
+          output << scanner.current_char
+          scanner.advance!
+          next
+        end
+
+        if scanner.parenthesis_depth.zero? && in_keyword_at?(scanner)
+          keyword_length = in_keyword_length_at(scanner)
+          parenthesis_position = find_opening_parenthesis(text, scanner.position + keyword_length)
+
+          if parenthesis_position
+            expansion = format_in_list(text, keyword_position: scanner.position, parenthesis_position: parenthesis_position, base_indent: base_indent)
+
+            if expansion
+              output << expansion[:text]
+              scanner.advance!(expansion[:consumed] - scanner.position)
+              next
+            end
+          end
+        end
+
+        output << scanner.current_char
+        scanner.advance!
+      end
+
+      output
+    end
+
+    def in_keyword_at?(scanner)
+      scanner.keyword_at?(NOT_IN_KEYWORD) || scanner.keyword_at?(IN_KEYWORD)
+    end
+
+    def in_keyword_length_at(scanner)
+      scanner.keyword_at?(NOT_IN_KEYWORD) ? NOT_IN_KEYWORD.length : IN_KEYWORD.length
+    end
+
+    def find_opening_parenthesis(text, from_position)
+      position = from_position
+
+      while position < text.length
+        return position if text[position] == Constants::OPEN_PARENTHESIS
+        return nil unless text[position] =~ Constants::WHITESPACE_CHARACTER_REGEX
+
+        position += 1
+      end
+
+      nil
+    end
+
+    def format_in_list(text, keyword_position:, parenthesis_position:, base_indent:)
+      closing_position = Scanner.new(text).find_matching_parenthesis(parenthesis_position)
+      return nil unless closing_position
+
+      inner_text = text[(parenthesis_position + 1)...closing_position]
+      return nil if inner_text.match?(SUBQUERY_PATTERN)
+
+      items = Tokenizer.split_by_top_level_commas(inner_text)
+      return nil if items.length <= 1
+
+      keyword_text = text[keyword_position...(parenthesis_position + 1)]
+      indent_spaces = SqlBeautifier.config_for(:indent_spaces)
+      item_indent = Util.whitespace(base_indent + indent_spaces)
+      closing_indent = Util.whitespace(base_indent)
+
+      formatted_items = items.map.with_index do |item, index|
+        trailing_comma = index < items.length - 1 ? "," : ""
+        "#{item_indent}#{item}#{trailing_comma}"
+      end
+
+      {
+        text: "#{keyword_text}\n#{formatted_items.join("\n")}\n#{closing_indent})",
+        consumed: closing_position + 1,
+      }
+    end
+
+    private_class_method :in_keyword_at?, :in_keyword_length_at, :find_opening_parenthesis, :format_in_list
+  end
+end

data/lib/sql_beautifier/version.rb

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

data/lib/sql_beautifier.rb

@@ -19,6 +19,7 @@ require_relative "sql_beautifier/table_reference"
 require_relative "sql_beautifier/table_registry"
 require_relative "sql_beautifier/join"
 require_relative "sql_beautifier/case_expression"
+require_relative "sql_beautifier/in_list"
 require_relative "sql_beautifier/expression"
 require_relative "sql_beautifier/sort_expression"
 require_relative "sql_beautifier/condition"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql_beautifier
 version: !ruby/object:Gem::Version
-  version: 0.10.3
+  version: 0.10.4
 platform: ruby
 authors:
 - Kinnell Shah
@@ -92,6 +92,7 @@ files:
 - lib/sql_beautifier/drop_table.rb
 - lib/sql_beautifier/expression.rb
 - lib/sql_beautifier/formatter.rb
+- lib/sql_beautifier/in_list.rb
 - lib/sql_beautifier/insert_query.rb
 - lib/sql_beautifier/join.rb
 - lib/sql_beautifier/normalizer.rb