rubocop-socketry 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 535ee9879245dcd6059d6ad744862b405ef49eec9203d70c8b07e03ca77b3f47
-  data.tar.gz: ccd2df428d0cb2652beb7452f0e80952e3dbe0845adb41bcebea5d8d83c0bff6
+  metadata.gz: 199a4f2c374f6e452459742724b7ba8ba9b0e9d9859ddf4ae12172a95e033bd9
+  data.tar.gz: ddc2c5a20e4b7181b1cdc0d07c53f85dc7acabb9ea4681616e3000292b45496f
 SHA512:
-  metadata.gz: 40daa847ae78f73f5c9d2a2521d457a8de458985dded66fb6d06e027c9545ce5dd65eeb3edd38d202fa4c87941ecdc9eee9cacb12d5a231a222acee64ddad889
-  data.tar.gz: da03f159be23f86eaea8b43fdfba3f80eca079b8e9c410c8a1f9e66d7e3e09f10e784944f8904fd40cd9d28dd5cd9124d79402633079bc637e3a55652b9c8000
+  metadata.gz: f04815a61b6651a7c4325967a9d193ade2ecb85800cb3ef816afed0a0f51d5849ab8a3aeb758474b93a8927b7fd984826f983749a9ff4824a0cf5beba1d72d95
+  data.tar.gz: 6b255a3e77c44782ea801bc3de112411896f9395ab0b78191998b8a064528a29cbca77bc50be56223f68c1b2df2e1155332f3985fd6e62bc935f5850a7b91553

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

@@ -14,26 +14,39 @@ module RuboCop
 			# - `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
 			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."
 				
 				def on_block(node)
 					return unless node.braces?
 					
 					send_node = node.send_node
 					
-					# Priority: Check if it's part of a method chain first
+					# 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
-					if part_of_method_chain?(node)
+					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)
 					elsif has_parentheses?(send_node)
 						# foo(1, 2) {bar} - space after ) for standalone methods
-						check_space_after_paren(node, send_node)
+						check_space_after_parentheses(node, send_node)
 					else
 						# foo {bar} - space for standalone methods without parens
 						check_space_before_brace(node, send_node)
@@ -42,6 +55,56 @@ module RuboCop
 				
 				private
 				
+				# Check if the send node is a lambda or proc (any form)
+				def lambda_or_proc?(send_node)
+					return true if send_node.lambda? # stabby lambda: ->{}
+					return true if send_node.method_name == :lambda # lambda keyword: lambda{}
+					return true if send_node.method_name == :proc # proc keyword: proc{}
+					
+					# Check for Proc.new{}
+					if send_node.method_name == :new && send_node.receiver&.const_type?
+						# Check if the receiver is the Proc constant
+						receiver = send_node.receiver
+						return true if receiver.const_name == :Proc && receiver.children.first.nil?
+					end
+					
+					false
+				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
+					
+					# 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_LAMBDA
+					) 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
@@ -63,7 +126,7 @@ module RuboCop
 				end
 				
 				# Check that there's a space between closing paren and opening brace
-				def check_space_after_paren(block_node, send_node)
+				def check_space_after_parentheses(block_node, send_node)
 					paren_end = send_node.loc.end
 					brace_begin = block_node.loc.begin
 					

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,27 +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
 				
@@ -46,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.5.0"
+		VERSION = "0.6.1"
 	end
 end 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-socketry
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Samuel Williams