rubocop-tablecop 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51eef2c0d5feffe748c3522a755b445f04c3a4b3375ae0aea80fed3abac7e3c6
-  data.tar.gz: d970c3c03b7cf9e4dc01c3184e276e79aaf7e88651d651f5f7d0b444ba7bad21
+  metadata.gz: 4b4eae624919db229c2973bf708c98fbb3493ae26c1442df19daded0b9f8b598
+  data.tar.gz: 1c0f7a64dc50fec124730b4d45c2a9b49044e05bad6984a91f45db43c5188e15
 SHA512:
-  metadata.gz: 19bed6636d3be68d97d506d660dab28f2470eb2e6f3dc94312809a32ee7909a66d914e3a1995e65278f38e4c8b21c4365cde21839528be48748dad27661bde65
-  data.tar.gz: e0c333e488389fee8c0cace9506b429e3eff5fed20b503ec2972ecbe5030c2b4791ba91cd5f8518e90338d48c93064a4c28b83e0f1507bf57bd7877d8be60b4d
+  metadata.gz: 4cd4fae66c17a7da85a859414f627475dc012902ceb4848a1ef84c9abd1c0236faad97ffdae718c3c9a635d1946d3b6c2a5c1e81734fd84f8916d32ad7d5e13e
+  data.tar.gz: 8cee4c0a8e542bebc8c7ea4e8a50fc4bb6c4cac8936f423cb45b7d08c650aced17c30d57484a0df8040834416d4a69b9e32d816e3274affa8ad9c0753a270907

data/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.1] - 2026-05-18
+
+### Fixed
+
+- **`Tablecop/SafeEndlessMethod` no longer corrupts methods whose body
+  contains a multi-statement `begin … end` nested as a sub-expression**
+  (e.g. the memoization idiom `@memo ||= begin; a; b; end`). The body
+  is an `or_asgn`, so the existing direct-body `:begin` guard missed
+  it, and it is not a `{}`/`do-end` block so the block guard missed it
+  too; autocorrect collapsed `a\n b` into `a b` (no separator) →
+  syntactically invalid Ruby. Found when it broke a downstream project
+  at parse time. Single-statement `begin x end` still converts.
+
+> Note: 0.3.0 was released without a changelog entry; entries resume
+> here rather than reconstruct unrecorded history.
+
 ## [0.2.0] - 2025-12-13
 
 ### Changed

data/config/default.yml

@@ -21,6 +21,11 @@ Tablecop/AlignMethods:
   Enabled: true
   VersionAdded: "0.1.0"
 
+Tablecop/CondenseIn:
+  Description: "Condense multi-line `in` clauses (pattern matching) to single lines when possible."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
 Tablecop/CondenseWhen:
   Description: "Condense multi-line `when` clauses to single lines when possible."
   Enabled: true

data/lib/rubocop/cop/tablecop/condense_in.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Tablecop
+      # Checks for multi-line `in` clauses (pattern matching) that could be
+      # condensed to a single line using the `then` keyword, with alignment.
+      #
+      # This cop encourages a table-like, vertically-aligned style for pattern
+      # matching case statements where each in clause fits on one line.
+      #
+      # When guard clauses are present, three-column alignment is used:
+      # patterns align, then `if` keywords align, then `then` keywords align.
+      #
+      # @example
+      #   # bad
+      #   case response
+      #   in [:ok, body]
+      #     handle_success(body)
+      #   in [:error, code]
+      #     handle_error(code)
+      #   end
+      #
+      #   # good (aligned)
+      #   case response
+      #   in [:ok, body]    then handle_success(body)
+      #   in [:error, code] then handle_error(code)
+      #   end
+      #
+      #   # good (with guards - three-column alignment)
+      #   case response
+      #   in [:ok, body]              then handle_success(body)
+      #   in [:error, code] if retry? then handle_retry(code)
+      #   in [:error, code]           then handle_error(code)
+      #   end
+      #
+      #   # also good (body too complex for single line)
+      #   case response
+      #   in [:ok, body]
+      #     log_success
+      #     handle_success(body)
+      #   end
+      #
+      class CondenseIn < Base
+        extend AutoCorrector
+
+        MSG = "Condense `in` to single line with aligned `then`"
+
+        def on_case_match(node)
+          in_nodes = node.in_pattern_branches
+          return if in_nodes.empty?
+
+          # Analyze which in-patterns can be condensed
+          condensable = in_nodes.map { |n| [n, condensable?(n)] }
+
+          # If none can be condensed, nothing to do
+          return unless condensable.any? { |_, can| can }
+
+          # Calculate alignment widths from all condensable in-patterns
+          max_pattern_width = calculate_max_pattern_width(condensable)
+          max_guard_width = calculate_max_guard_width(condensable)
+
+          # Check if alignment would exceed line length for any condensable in-pattern
+          use_alignment = can_align_all?(condensable, max_pattern_width, max_guard_width, node)
+
+          # Register offenses and corrections for each condensable in-pattern
+          condensable.each do |in_node, can_condense|
+            next unless can_condense
+            next if in_node.single_line?  # Already condensed
+
+            register_offense(in_node, max_pattern_width, max_guard_width, use_alignment, node)
+          end
+        end
+
+        private
+
+        def condensable?(node)
+          # Must have a body
+          return false unless node.body
+
+          # Body must be a simple single expression (not begin block with multiple statements)
+          return false if node.body.begin_type? && node.body.children.size > 1
+
+          # No heredocs
+          return false if contains_heredoc?(node.body)
+
+          # No multi-line strings
+          return false if contains_multiline_string?(node.body)
+
+          # No control flow that can't be safely condensed
+          return false if contains_complex_control_flow?(node.body)
+
+          # No comments between in and body
+          return false if comment_between?(node)
+
+          # Pattern must be on one line
+          return false unless pattern_single_line?(node)
+
+          # Guard (if present) must be on one line
+          return false unless guard_single_line?(node)
+
+          # Check if condensed form would exceed line length (without alignment)
+          single_line = build_single_line(node, 0, 0)
+          base_indent = node.loc.keyword.column
+          return false if (base_indent + single_line.length) > max_line_length
+
+          true
+        end
+
+        def calculate_max_pattern_width(condensable)
+          condensable
+            .select { |_, can| can }
+            .map { |n, _| pattern_width(n) }
+            .max || 0
+        end
+
+        def calculate_max_guard_width(condensable)
+          condensable
+            .select { |_, can| can }
+            .map { |n, _| guard_width(n) }
+            .max || 0
+        end
+
+        def pattern_width(in_node)
+          in_node.pattern.source.length
+        end
+
+        def guard_width(in_node)
+          guard = in_node.children[1]
+          return 0 unless guard
+
+          guard.source.length
+        end
+
+        def can_align_all?(condensable, max_pattern_width, max_guard_width, case_node)
+          base_indent = case_node.loc.keyword.column
+
+          condensable.all? do |in_node, can_condense|
+            next true unless can_condense
+            next true if in_node.single_line?
+
+            # Check if aligned version fits
+            single_line = build_single_line(in_node, max_pattern_width, max_guard_width)
+            (base_indent + single_line.length) <= max_line_length
+          end
+        end
+
+        def build_single_line(in_node, pad_pattern_to, pad_guard_to)
+          pattern_source = in_node.pattern.source
+          body_source = in_node.body.source.gsub(/\s*\n\s*/, " ").strip
+          guard = in_node.children[1]
+
+          if pad_pattern_to > 0
+            pattern_padding = " " * (pad_pattern_to - pattern_source.length)
+
+            if guard
+              guard_source = guard.source
+              guard_padding = " " * (pad_guard_to - guard_source.length)
+              "in #{pattern_source}#{pattern_padding} #{guard_source}#{guard_padding} then #{body_source}"
+            elsif pad_guard_to > 0
+              # No guard on this branch, but other branches have guards
+              # Pad to align with where 'then' would be after guards
+              total_padding = " " * (pad_pattern_to - pattern_source.length + pad_guard_to + 1)
+              "in #{pattern_source}#{total_padding} then #{body_source}"
+            else
+              "in #{pattern_source}#{pattern_padding} then #{body_source}"
+            end
+          else
+            if guard
+              "in #{pattern_source} #{guard.source} then #{body_source}"
+            else
+              "in #{pattern_source} then #{body_source}"
+            end
+          end
+        end
+
+        def register_offense(in_node, max_pattern_width, max_guard_width, use_alignment, _case_node)
+          add_offense(in_node) do |corrector|
+            pattern_width = use_alignment ? max_pattern_width : 0
+            guard_width = use_alignment ? max_guard_width : 0
+            single_line = build_single_line(in_node, pattern_width, guard_width)
+            corrector.replace(in_node, single_line)
+          end
+        end
+
+        def pattern_single_line?(node)
+          pattern = node.pattern
+          pattern.first_line == pattern.last_line
+        end
+
+        def guard_single_line?(node)
+          guard = node.children[1]
+          return true unless guard
+
+          guard.first_line == guard.last_line
+        end
+
+        def contains_heredoc?(node)
+          return false unless node
+
+          return true if node.respond_to?(:heredoc?) && node.heredoc?
+
+          node.each_descendant(:str, :dstr, :xstr).any?(&:heredoc?)
+        end
+
+        def contains_multiline_string?(node)
+          return false unless node
+
+          node.each_descendant(:str, :dstr).any? do |str_node|
+            next false if str_node.heredoc?
+
+            str_node.source.include?("\n")
+          end
+        end
+
+        def contains_complex_control_flow?(node)
+          return false unless node
+
+          # Multi-line if/unless/case can't be condensed safely
+          if node.if_type? || node.case_type? || node.case_match_type?
+            return true unless node.single_line?
+          end
+
+          # Check for multi-statement blocks
+          node.each_descendant(:block, :numblock) do |block_node|
+            return true if block_node.body&.begin_type?
+          end
+
+          # Check descendants for complex control flow
+          node.each_descendant(:if, :case, :case_match) do |control_node|
+            return true unless control_node.single_line?
+          end
+
+          false
+        end
+
+        def comment_between?(in_node)
+          return false unless in_node.body
+
+          comments = processed_source.comments
+          in_line = in_node.loc.keyword.line
+          body_line = in_node.body.first_line
+
+          comments.any? do |comment|
+            comment.loc.line.between?(in_line, body_line - 1)
+          end
+        end
+
+        def max_line_length
+          config.for_cop("Layout/LineLength")["Max"] || 120
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/tablecop/safe_endless_method.rb

@@ -66,6 +66,16 @@ module RuboCop
           # Body must be single expression (not begin block with multiple children)
           return false if node.body.begin_type?
 
+          # ...and must not CONTAIN a multi-statement sequence anywhere
+          # (e.g. `@memo ||= begin; a; b; end` — body is an or_asgn, so
+          # the check above misses it, and it is not a {}/do-end block so
+          # contains_multi_statement_block? misses it too). Collapsing its
+          # newlines to spaces would jam `a b` with no separator → invalid
+          # Ruby. This was a real corruption: rubocop-tablecop#<safe-
+          # endless> turned a valid memoized method into an unparseable
+          # one in a downstream project.
+          return false if contains_multi_statement_sequence?(node.body)
+
           # No heredocs
           return false if contains_heredoc?(node.body)
 
@@ -151,6 +161,19 @@ module RuboCop
           false
         end
 
+        # True if `body` is, or contains anywhere, a statement sequence
+        # with more than one statement. Two AST shapes (verified, not
+        # assumed): an implicit multi-statement body is a `:begin`
+        # sequence; an explicit `begin … end` is a `:kwbegin` whose
+        # children ARE the statements (no inner `:begin`). Either with
+        # >1 child is unsafe to space-join. Single-statement `begin x
+        # end` is a 1-child :kwbegin and stays convertible.
+        def contains_multi_statement_sequence?(body)
+          return false unless body
+
+          body.each_node(:begin, :kwbegin).any? { |seq| seq.children.size > 1 }
+        end
+
         def contains_complex_control_flow?(node)
           return false unless node
 

data/lib/rubocop/cop/tablecop_cops.rb

@@ -2,5 +2,6 @@
 
 require_relative "tablecop/align_assignments"
 require_relative "tablecop/align_methods"
+require_relative "tablecop/condense_in"
 require_relative "tablecop/condense_when"
 require_relative "tablecop/safe_endless_method"

data/lib/rubocop/tablecop/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Tablecop
     # Version information for rubocop-tablecop.
     module Version
-      STRING = "0.2.0"
+      STRING = "0.3.1"
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-tablecop
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Joseph Wecker
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -53,6 +52,7 @@ files:
 - lib/rubocop-tablecop.rb
 - lib/rubocop/cop/tablecop/align_assignments.rb
 - lib/rubocop/cop/tablecop/align_methods.rb
+- lib/rubocop/cop/tablecop/condense_in.rb
 - lib/rubocop/cop/tablecop/condense_when.rb
 - lib/rubocop/cop/tablecop/safe_endless_method.rb
 - lib/rubocop/cop/tablecop_cops.rb
@@ -67,7 +67,6 @@ metadata:
   changelog_uri: https://github.com/v2-io/rubocop-tablecop/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
   default_lint_roller_plugin: RuboCop::Tablecop::Plugin
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -82,8 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: RuboCop extension for table-like, condensed Ruby formatting
 test_files: []