rubocop-tablecop 0.2.0

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

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Tablecop
+      # Aligns consecutive assignment statements on the `=` operator.
+      #
+      # Handles simple assignments (`=`), compound assignments (`||=`, `&&=`, `+=`, etc.),
+      # and constant assignments. Skips lines containing heredocs entirely to avoid
+      # infinite loops with Layout/SpaceAroundOperators.
+      #
+      # @example
+      #   # bad
+      #   x = 1
+      #   foo = 2
+      #   barbaz = 3
+      #
+      #   # good
+      #   x      = 1
+      #   foo    = 2
+      #   barbaz = 3
+      #
+      # @example Compound operators
+      #   # bad
+      #   data ||= attrs
+      #   options = default
+      #
+      #   # good
+      #   data    ||= attrs
+      #   options = default
+      #
+      class AlignAssignments < Base
+        extend AutoCorrector
+
+        MSG = "Align assignment with other assignments in group"
+
+        # Assignment types we handle
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn op_asgn or_asgn and_asgn].freeze
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          groups = find_assignment_groups
+          groups.each { |group| check_group(group) }
+        end
+
+        private
+
+        def find_assignment_groups
+          assignments = find_assignments
+          return [] if assignments.empty?
+
+          groups = []
+          current_group = [assignments.first]
+
+          assignments.each_cons(2) do |prev, curr|
+            if consecutive_lines?(prev, curr) && same_indent?(prev, curr)
+              current_group << curr
+            else
+              groups << current_group if current_group.size > 1
+              current_group = [curr]
+            end
+          end
+
+          groups << current_group if current_group.size > 1
+          groups
+        end
+
+        def find_assignments
+          return [] unless processed_source.ast
+
+          assignments = []
+
+          processed_source.ast.each_node(*ASSIGNMENT_TYPES) do |node|
+            # Skip if this assignment contains a heredoc
+            next if contains_heredoc?(node)
+
+            # Skip multi-assignment (a, b = ...)
+            # These have parent :mlhs (multiple left-hand side)
+            next if node.parent&.type == :masgn || node.parent&.type == :mlhs
+
+            # Skip inner lvasgn/ivasgn that are part of op_asgn/or_asgn/and_asgn
+            # (these compound assignments have the simple asgn as first child)
+            next if node.parent&.type&.to_s&.end_with?("_asgn") &&
+                    %i[lvasgn ivasgn cvasgn gvasgn].include?(node.type)
+
+            # Skip array/hash element assignment (hash[:key] = val)
+            # These are actually send nodes with :[]= method
+            next if node.type == :send && node.method_name == :[]=
+
+            # Only include if it's on a single line
+            next unless node.single_line?
+
+            # Skip assignments inside blocks - they shouldn't align with
+            # assignments outside the block
+            next if inside_block?(node)
+
+            assignments << node
+          end
+
+          assignments.sort_by(&:first_line)
+        end
+
+        def consecutive_lines?(prev_node, curr_node)
+          curr_node.first_line == prev_node.last_line + 1
+        end
+
+        def same_indent?(node1, node2)
+          indent(node1) == indent(node2)
+        end
+
+        def indent(node)
+          processed_source.lines[node.first_line - 1] =~ /\S/
+        end
+
+        def check_group(group)
+          eq_cols = group.map { |node| equals_column(node) }
+          max_eq_col = eq_cols.max
+
+          return unless can_align_all?(group, eq_cols, max_eq_col)
+
+          group.each_with_index do |node, idx|
+            padding_needed = max_eq_col - eq_cols[idx]
+            next if padding_needed <= 0
+
+            register_offense(node, padding_needed)
+          end
+        end
+
+        def equals_column(node)
+          case node.type
+          when :lvasgn, :ivasgn, :cvasgn, :gvasgn
+            # Simple assignment: variable = value
+            # The operator loc is not directly available, find it from source
+            find_operator_column(node)
+          when :casgn
+            # Constant assignment: CONST = value
+            find_operator_column(node)
+          when :op_asgn, :or_asgn, :and_asgn
+            # Compound assignment: var += val, var ||= val, var &&= val
+            node.loc.operator.column
+          else
+            find_operator_column(node)
+          end
+        end
+
+        def find_operator_column(node)
+          # For simple assignments, find the = in the source
+          line = processed_source.lines[node.first_line - 1]
+
+          # Find the first = that's part of an assignment (not ==, !=, etc.)
+          # Start after the LHS
+          lhs_end = lhs_end_column(node)
+
+          # Search for = after LHS
+          rest_of_line = line[lhs_end..]
+          eq_match = rest_of_line&.match(/\s*(=)(?!=)/)
+
+          if eq_match
+            lhs_end + eq_match.begin(1)
+          else
+            # Fallback: use the LHS end position
+            lhs_end
+          end
+        end
+
+        def lhs_end_column(node)
+          case node.type
+          when :lvasgn
+            node.loc.name.end_pos - processed_source.buffer.line_range(node.first_line).begin_pos
+          when :ivasgn, :cvasgn, :gvasgn
+            node.loc.name.end_pos - processed_source.buffer.line_range(node.first_line).begin_pos
+          when :casgn
+            node.loc.name.end_pos - processed_source.buffer.line_range(node.first_line).begin_pos
+          else
+            0
+          end
+        end
+
+        def padding_insert_position(node)
+          case node.type
+          when :op_asgn, :or_asgn, :and_asgn
+            node.loc.operator.begin_pos
+          else
+            # For simple assignments, insert before the =
+            line = processed_source.lines[node.first_line - 1]
+            line_start = processed_source.buffer.line_range(node.first_line).begin_pos
+            lhs_end = lhs_end_column(node)
+
+            rest_of_line = line[lhs_end..]
+            eq_match = rest_of_line&.match(/\s*(=)(?!=)/)
+
+            if eq_match
+              line_start + lhs_end + eq_match.begin(1)
+            else
+              line_start + lhs_end
+            end
+          end
+        end
+
+        def can_align_all?(group, eq_cols, max_eq_col)
+          group.each_with_index.all? do |node, idx|
+            padding = max_eq_col - eq_cols[idx]
+            line_length(node) + padding <= max_line_length
+          end
+        end
+
+        def line_length(node)
+          processed_source.lines[node.first_line - 1].length
+        end
+
+        def contains_heredoc?(node)
+          return false unless node
+
+          node.each_descendant(:str, :dstr, :xstr).any? do |str_node|
+            str_node.heredoc?
+          end
+        end
+
+        def inside_block?(node)
+          node.each_ancestor(:block, :numblock).any?
+        end
+
+        def register_offense(node, padding_needed)
+          add_offense(node) do |corrector|
+            pos = padding_insert_position(node)
+            corrector.insert_before(
+              Parser::Source::Range.new(processed_source.buffer, pos, pos),
+              " " * padding_needed
+            )
+          end
+        end
+
+        def max_line_length
+          config.for_cop("Layout/LineLength")["Max"] || 120
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Tablecop
+      # Aligns contiguous single-line method definitions so their bodies start
+      # at the same column. Aligns on `=` for endless methods; traditional
+      # one-liners align as if they had an invisible `=`.
+      #
+      # @example
+      #   # bad
+      #   def foo = 1
+      #   def barbaz = 2
+      #
+      #   # good
+      #   def foo    = 1
+      #   def barbaz = 2
+      #
+      # @example Mixed endless and traditional
+      #   # bad
+      #   def foo = 1
+      #   def bar() 2 end
+      #
+      #   # good
+      #   def foo   = 1
+      #   def bar()   2 end
+      #
+      class AlignMethods < Base
+        extend AutoCorrector
+
+        MSG = "Align method body with other methods in group"
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          groups = find_method_groups
+          groups.each { |group| check_group(group) }
+        end
+
+        private
+
+        def find_method_groups
+          methods = single_line_methods
+          return [] if methods.empty?
+
+          groups = []
+          current_group = [methods.first]
+
+          methods.each_cons(2) do |prev, curr|
+            if consecutive_lines?(prev, curr) && same_indent?(prev, curr)
+              current_group << curr
+            else
+              groups << current_group if current_group.size > 1
+              current_group = [curr]
+            end
+          end
+
+          groups << current_group if current_group.size > 1
+          groups
+        end
+
+        def single_line_methods
+          return [] unless processed_source.ast
+
+          processed_source.ast.each_descendant(:def).select(&:single_line?).sort_by(&:first_line)
+        end
+
+        def consecutive_lines?(prev_node, curr_node)
+          curr_node.first_line == prev_node.last_line + 1
+        end
+
+        def same_indent?(node1, node2)
+          node1.loc.keyword.column == node2.loc.keyword.column
+        end
+
+        def check_group(group)
+          # Calculate the column of `=` (or where `=` would be) for each method
+          eq_cols = group.map { |node| equals_column(node) }
+          max_eq_col = eq_cols.max
+
+          # Check if alignment would exceed line length for any method
+          return unless can_align_all?(group, eq_cols, max_eq_col)
+
+          group.each_with_index do |node, idx|
+            padding_needed = max_eq_col - eq_cols[idx]
+            next if padding_needed <= 0
+
+            register_offense(node, padding_needed)
+          end
+        end
+
+        # Returns the column where `=` is (endless) or would be (traditional)
+        def equals_column(node)
+          if node.endless?
+            node.loc.assignment.column
+          else
+            # For traditional: body column - 2 (pretend there's ` = ` before body)
+            # Actually, we want to align bodies, so use body column directly
+            # but we insert padding before body, effectively making ` = ` align
+            node.body.loc.expression.column - 2
+          end
+        end
+
+        # Position to insert padding
+        def padding_insert_position(node)
+          if node.endless?
+            node.loc.assignment.begin_pos
+          else
+            node.body.loc.expression.begin_pos
+          end
+        end
+
+        def can_align_all?(group, eq_cols, max_eq_col)
+          group.each_with_index.all? do |node, idx|
+            padding = max_eq_col - eq_cols[idx]
+            line_length(node) + padding <= max_line_length
+          end
+        end
+
+        def line_length(node)
+          processed_source.lines[node.first_line - 1].length
+        end
+
+        def register_offense(node, padding_needed)
+          add_offense(node) do |corrector|
+            pos = padding_insert_position(node)
+            corrector.insert_before(
+              Parser::Source::Range.new(processed_source.buffer, pos, pos),
+              " " * padding_needed
+            )
+          end
+        end
+
+        def max_line_length
+          config.for_cop("Layout/LineLength")["Max"] || 120
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Tablecop
+      # Checks for multi-line `when` clauses that could be condensed to a single
+      # line using the `then` keyword, and aligns `then` keywords across siblings.
+      #
+      # This cop encourages a table-like, vertically-aligned style for case
+      # statements where each when clause fits on one line.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when 1
+      #     "one"
+      #   when 200
+      #     "two hundred"
+      #   end
+      #
+      #   # good (aligned)
+      #   case foo
+      #   when 1   then "one"
+      #   when 200 then "two hundred"
+      #   end
+      #
+      #   # also good (body too complex for single line)
+      #   case foo
+      #   when 1
+      #     do_something
+      #     do_something_else
+      #   end
+      #
+      class CondenseWhen < Base
+        extend AutoCorrector
+
+        MSG = "Condense `when` to single line with aligned `then`"
+
+        def on_case(node)
+          when_nodes = node.when_branches
+          return if when_nodes.empty?
+
+          # Analyze which whens can be condensed
+          condensable = when_nodes.map { |w| [w, condensable?(w)] }
+
+          # If none can be condensed, nothing to do
+          return unless condensable.any? { |_, can| can }
+
+          # Calculate alignment width from all condensable whens
+          max_condition_width = calculate_max_condition_width(condensable)
+
+          # Check if alignment would exceed line length for any condensable when
+          use_alignment = can_align_all?(condensable, max_condition_width, node)
+
+          # Register offenses and corrections for each condensable when
+          condensable.each do |when_node, can_condense|
+            next unless can_condense
+            next if when_node.single_line?  # Already condensed
+
+            register_offense(when_node, max_condition_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
+          # (if/unless/case with else, multi-statement blocks, etc.)
+          return false if contains_complex_control_flow?(node.body)
+
+          # No comments between when and body
+          return false if comment_between?(node)
+
+          # Conditions must be on one line
+          return false unless conditions_single_line?(node)
+
+          # Check if condensed form would exceed line length (without alignment)
+          single_line = build_single_line(node, 0)
+          base_indent = node.loc.keyword.column
+          return false if (base_indent + single_line.length) > max_line_length
+
+          true
+        end
+
+        def calculate_max_condition_width(condensable)
+          condensable
+            .select { |_, can| can }
+            .map { |w, _| condition_width(w) }
+            .max || 0
+        end
+
+        def condition_width(when_node)
+          when_node.conditions.map(&:source).join(", ").length
+        end
+
+        def can_align_all?(condensable, max_width, case_node)
+          base_indent = case_node.loc.keyword.column
+
+          condensable.all? do |when_node, can_condense|
+            next true unless can_condense
+            next true if when_node.single_line?
+
+            # Check if aligned version fits
+            single_line = build_single_line(when_node, max_width)
+            (base_indent + single_line.length) <= max_line_length
+          end
+        end
+
+        def build_single_line(when_node, pad_to_width)
+          conditions_source = when_node.conditions.map(&:source).join(", ")
+          body_source = when_node.body.source.gsub(/\s*\n\s*/, " ").strip
+
+          if pad_to_width > 0
+            padding = " " * (pad_to_width - conditions_source.length)
+            "when #{conditions_source}#{padding} then #{body_source}"
+          else
+            "when #{conditions_source} then #{body_source}"
+          end
+        end
+
+        def register_offense(when_node, max_width, use_alignment, _case_node)
+          add_offense(when_node) do |corrector|
+            width = use_alignment ? max_width : 0
+            single_line = build_single_line(when_node, width)
+            corrector.replace(when_node, single_line)
+          end
+        end
+
+        def conditions_single_line?(node)
+          return true if node.conditions.size == 1
+
+          first_cond = node.conditions.first
+          last_cond = node.conditions.last
+          first_cond.first_line == last_cond.last_line
+        end
+
+        def contains_heredoc?(node)
+          return false unless node
+
+          # Check the node itself if it's a string type
+          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?
+            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) do |control_node|
+            return true unless control_node.single_line?
+          end
+
+          false
+        end
+
+        def comment_between?(when_node)
+          return false unless when_node.body
+
+          comments = processed_source.comments
+          when_line = when_node.loc.keyword.line
+          body_line = when_node.body.first_line
+
+          comments.any? do |comment|
+            comment.loc.line.between?(when_line, body_line - 1)
+          end
+        end
+
+        def max_line_length
+          config.for_cop("Layout/LineLength")["Max"] || 120
+        end
+      end
+    end
+  end
+end