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 = foobar` - 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).

  • ‘lambdafoo` - no space for lambda keyword.

  • ‘procfoo` - no space for proc keyword.

  • ‘Proc.newfoo` - 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 



30
31
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
 
# File 'lib/rubocop/socketry/layout/block_delimiter_spacing.rb', line 30

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