rubocop-socketry 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45d8b27941b7424a315428ba04dd6dc98218896b54551f49f0cdde531c41b1af
-  data.tar.gz: d602b39fd19660eb34908a17c0681fd884d7d2fb9b14395e1f2070ee54910ced
+  metadata.gz: 3bdf0fc2d1db810ae5d2bb5d15895f763062e83a4cff437e17f9707b4f9f7d27
+  data.tar.gz: f615231a3fa949865a21623f160195da22ad401e2198db990a5ebffa9554dea4
 SHA512:
-  metadata.gz: f3dbbc01b527507b658225ad95dcce305a1c33764636a88d3f83f7772a9c5264e7729d4d554335c4427c13f66b3a7535ef05e11842c0acddfa88d143a9cea83b
-  data.tar.gz: a09b66c884a2258df7e9f53010af7fe638ac6454b4c36195406136b694116f9f5cb16465e7d67bdbddfd872b525f10dfc104cd8bcc659c323209b5a4f759c2fe
+  metadata.gz: aa0b76dd902e2bbfc9409a54c242b15912cc850c9c2a3f26618adedc5a6275eb0d2c690eb224b23f0fbe620e777f2f0efbf0c58a3d7c2d7e324e233323e736d7
+  data.tar.gz: 40c8ad00c40ee7619c6f3f9ccf3e22bd5a4a71c1920683c326a21a80cd90620bb4f34acaeabe469c01991e4ee304e38aed89381fb05a2a7b66652e50bee9a0ff

data/lib/rubocop/socketry/layout/block_delimiter_spacing.rb

@@ -11,19 +11,21 @@ module RuboCop
 			# A RuboCop cop that enforces consistent spacing before block delimiters.
 			# 
 			# This cop enforces the following style:
-			# - `foo {bar}` - space when method has no parentheses and is not chained
-			# - `foo(1, 2) {bar}` - space after closing paren for standalone methods
-			# - `array.each{|x| x*2}.reverse` - no space for method chains (even with parens)
-			# - `->(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
+			# - `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`.
 			class BlockDelimiterSpacing < RuboCop::Cop::Base
 				extend Cop::AutoCorrector
 				
 				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."
 				
 				def on_block(node)
 					return unless node.braces?
@@ -44,6 +46,12 @@ module RuboCop
 						# 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)
@@ -71,6 +79,18 @@ module RuboCop
 					false
 				end
 				
+				# Check if the block is part of an expression (not a top-level statement)
+				# Top-level statements are directly inside a :begin node (file/method body)
+				# and should have space. Everything else (expressions, nested blocks) should not.
+				def part_of_expression?(node)
+					parent = node.parent
+					return false unless parent
+					
+					# If parent is a :begin node (sequence of statements), this is top-level
+					# Otherwise, it's part of an expression or nested context
+					parent.type != :begin
+				end
+				
 				# Check that there's no space before the opening brace for lambdas
 				def check_no_space_for_lambda(block_node, send_node)
 					brace_begin = block_node.loc.begin
@@ -105,6 +125,40 @@ module RuboCop
 					end
 				end
 				
+				# Check that there's no space before the opening brace for expressions
+				def check_no_space_for_expression(block_node, send_node)
+					brace_begin = block_node.loc.begin
+					
+					# Find the position just before the brace
+					char_before_pos = brace_begin.begin_pos - 1
+					
+					return if char_before_pos < 0
+					
+					char_before = processed_source.buffer.source[char_before_pos]
+					
+					# If there's no space before the brace, we're good
+					return unless char_before == " "
+					
+					# Find the extent of whitespace before the brace
+					start_pos = char_before_pos
+					while start_pos > 0 && processed_source.buffer.source[start_pos - 1] =~ /\s/
+						start_pos -= 1
+					end
+					
+					space_range = Parser::Source::Range.new(
+						processed_source.buffer,
+						start_pos,
+						brace_begin.begin_pos
+					)
+					
+					add_offense(
+						space_range,
+						message: MSG_REMOVE_SPACE_EXPRESSION
+					) do |corrector|
+						corrector.remove(space_range)
+					end
+				end
+				
 				# Check if the block is part of a method chain (e.g., foo{}.bar or foo.bar{}.baz)
 				def part_of_method_chain?(block_node)
 					send_node = block_node.send_node

data/lib/rubocop/socketry/style/global_exception_variables.rb

@@ -8,7 +8,7 @@ require "rubocop"
 module RuboCop
 	module Socketry
 		module Style
-			# A RuboCop cop that warns against using global exception variables.
+			# A RuboCop cop that warns against using global exception variables in unsafe contexts.
 			# 
 			# This cop discourages the use of:
 			# - `$!` (last exception)
@@ -17,26 +17,52 @@ module RuboCop
 			# - `$ERROR_POSITION` (English name for `$@`)
 			# 
 			# These global variables are implicit and can make code harder to understand.
-			# Instead, use explicit exception handling with rescue blocks and local variables.
+			# 
+			# However, this cop allows their use in safe contexts where the scope is well-defined:
+			# - Inside rescue blocks (well-defined scope)
+			# - In rescue modifiers (`expression rescue $!`)
+			# - In method parameter defaults (`def foo(error = $!)`, `def bar(error: $!)`)
+			# 
+			# This cop specifically flags their use in unsafe contexts:
+			# - Inside ensure blocks (extremely unsafe - exception state is unpredictable)
+			# - Outside of exception handling contexts
 			# 
 			# @example
-			#   # bad
+			#   # bad - unsafe in ensure block
 			#   begin
 			#     risky_operation
-			#   rescue
+			#   ensure
+			#     log($!.message) if $!  # unsafe!
+			#   end
+			# 
+			#   # bad - outside exception handling
+			#   def process
 			#     puts $!.message
-			#     puts $@.first
 			#   end
 			# 
-			#   # good
+			#   # good - explicit exception handling
 			#   begin
 			#     risky_operation
 			#   rescue => error
 			#     puts error.message
-			#     puts error.backtrace.first
 			#   end
+			# 
+			#   # allowed - inside rescue block (well-defined scope)
+			#   begin
+			#     risky_operation
+			#   rescue
+			#     puts $!.message
+			#   end
+			# 
+			#   # allowed - rescue modifier
+			#   result = risky_operation rescue $!
+			# 
+			#   # allowed - parameter defaults
+			#   def foo(error = $!)
+			#   def bar(error: $!)
 			class GlobalExceptionVariables < RuboCop::Cop::Base
-				MSG = "Avoid using global exception variable `%<variable>s`. Use explicit exception handling with `rescue => error` instead."
+				MSG = "Avoid using global exception variable `%<variable>s` in %<context>s. Use explicit exception handling with `rescue => error` instead."
+				ENSURE_MSG = "Using global exception variable `%<variable>s` in an ensure block is extremely unsafe."
 				
 				EXCEPTION_VARIABLES = %i[$! $@ $ERROR_INFO $ERROR_POSITION].freeze
 				
@@ -45,11 +71,53 @@ module RuboCop
 					
 					return unless EXCEPTION_VARIABLES.include?(variable_name)
 					
+					# Allow in parameter defaults (explicitly opting in)
+					return if in_parameter_default?(node)
+					
+					# Allow in rescue modifier (well-defined scope)
+					return if in_rescue_modifier?(node)
+					
+					# Allow in rescue block (well-defined scope)
+					return if in_rescue_block?(node)
+					
+					# Flag if in ensure block (extremely unsafe)
+					if in_ensure_block?(node)
+						add_offense(
+							node,
+							message: format(ENSURE_MSG, variable: variable_name)
+						)
+						return
+					end
+					
+					# Flag in all other contexts
 					add_offense(
 						node,
-						message: format(MSG, variable: variable_name)
+						message: format(MSG, variable: variable_name, context: "this context")
 					)
 				end
+				
+				private
+				
+				def in_parameter_default?(node)
+					node.each_ancestor(:args, :optarg, :kwoptarg).any?
+				end
+				
+				def in_rescue_modifier?(node)
+					node.each_ancestor(:rescue).any? do |ancestor|
+						# A rescue modifier has no resbody children
+						# e.g., `expression rescue $!` is a rescue node with 2 children: expression and handler
+						# A regular rescue has resbody children
+						!ancestor.children.any?{|child| child.is_a?(RuboCop::AST::Node) && child.type == :resbody}
+					end
+				end
+				
+				def in_rescue_block?(node)
+					node.each_ancestor(:resbody).any?
+				end
+				
+				def in_ensure_block?(node)
+					node.each_ancestor(:ensure).any?
+				end
 			end
 		end
 	end

data/lib/rubocop/socketry/version.rb

@@ -5,6 +5,6 @@
 
 module RuboCop
 	module Socketry
-		VERSION = "0.6.0"
+		VERSION = "0.7.0"
 	end
 end 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-socketry
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -103,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: RuboCop rules for Socketry projects
 test_files: []