Class: RuboCop::Socketry::Layout::BlockDelimiterSpacing

Inherits:
Cop::Base
  • Object
show all
Extended by:
Cop::AutoCorrector
Defined in:
lib/rubocop/socketry/layout/block_delimiter_spacing.rb

Overview

A RuboCop cop that enforces consistent spacing before block delimiters.

This cop enforces the following style:

  • foo {bar} - space for top-level statements without parentheses.
  • x = foo{bar} - no space when part of an expression (assignment, argument, etc).
  • foo(1, 2) {bar} - space after closing paren for top-level statements.
  • array.each{|x| x*2}.reverse - no space for method chains.
  • ->(foo){foo} - no space for lambdas (stabby lambda syntax).
  • lambda{foo} - no space for lambda keyword.
  • proc{foo} - no space for proc keyword.
  • Proc.new{foo} - no space for Proc.new.

Constant Summary collapse

MSG_ADD_SPACE = 
"Add a space before the opening brace."
MSG_REMOVE_SPACE = 
"Remove space before the opening brace for method chains."
MSG_REMOVE_SPACE_LAMBDA = 
"Remove space before the opening brace for lambdas/procs."
MSG_REMOVE_SPACE_EXPRESSION = 
"Remove space before the opening brace for expressions."

Instance Method Summary collapse

Instance Method Details

#on_block(node) ⇒ Object

Check each brace-delimited block for the required spacing before {.



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/rubocop/socketry/layout/block_delimiter_spacing.rb', line 32

def on_block(node)
	return unless node.braces?
	
	send_node = node.send_node
	
	# Priority 1: Check if it's a lambda or proc
	# Lambdas/procs should never have space before {
	if lambda_or_proc?(send_node)
		# ->(foo){foo} - no space (stabby lambda)
		# lambda{foo} - no space (lambda keyword)
		# proc{foo} - no space (proc keyword)
		# Proc.new{foo} - no space (Proc.new)
		check_no_space_for_lambda(node, send_node)
	# Priority 2: Check if it's part of a method chain
	# Method chains should never have space, even with parentheses
	elsif part_of_method_chain?(node)
		# array.each{|x| x*2}.reverse - no space
		# obj.method(1, 2){|x| x}.other - also no space
		check_no_space_before_brace(node, send_node)
	# Priority 3: Check if it's part of an expression (not top-level)
	# Blocks within expressions should have no space
	elsif part_of_expression?(node)
		# x = Async{server.run} - no space (part of assignment)
		# foo(bar{baz}) - no space (part of argument)
		check_no_space_for_expression(node, send_node)
	elsif has_parentheses?(send_node)
		# foo(1, 2) {bar} - space after ) for standalone methods
		check_space_after_parentheses(node, send_node)
	else
		# foo {bar} - space for standalone methods without parens
		check_space_before_brace(node, send_node)
	end
end