rubocop-thread_safety 0.5.1 → 0.6.0

data/gemfiles/rubocop_1.66.gemfile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# This file was generated by Appraisal
+
+source 'https://rubygems.org'
+
+gem 'appraisal'
+gem 'bundler', '>= 1.10', '< 3'
+gem 'prism', '~> 1.2.0'
+gem 'pry'
+gem 'rake', '>= 10.0'
+gem 'rspec', '~> 3.0'
+gem 'rubocop', '~> 1.66.0'
+gem 'rubocop-rake', '~> 0.6.0'
+gem 'rubocop-rspec'
+gem 'simplecov'
+gem 'yard'
+
+gemspec path: '../'

data/lib/rubocop/cop/mixin/operation_with_threadsafe_result.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking if a well-known operation
+    # produces an object with thread-safe semantics.
+    module OperationWithThreadsafeResult
+      extend NodePattern::Macros
+
+      # @!method operation_produces_threadsafe_object?(node)
+      def_node_matcher :operation_produces_threadsafe_object?, <<~PATTERN
+        {
+          (send (const {nil? cbase} :Queue) :new ...)
+          (send
+            (const (const {nil? cbase} :ThreadSafe) {:Hash :Array})
+            :new ...)
+          (block
+            (send
+              (const (const {nil? cbase} :ThreadSafe) {:Hash :Array})
+              :new ...)
+            ...)
+          (send (const (const {nil? cbase} :Concurrent) _) :new ...)
+          (block
+            (send (const (const {nil? cbase} :Concurrent) _) :new ...)
+            ...)
+          (send (const (const (const {nil? cbase} :Concurrent) _) _) :new ...)
+          (block
+            (send
+              (const (const (const {nil? cbase} :Concurrent) _) _)
+              :new ...)
+            ...)
+          (send
+            (const (const (const (const {nil? cbase} :Concurrent) _) _) _)
+            :new ...)
+          (block
+            (send
+              (const (const (const (const {nil? cbase} :Concurrent) _) _) _)
+              :new ...)
+            ...)
+        }
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/thread_safety/class_and_module_attributes.rb

@@ -50,8 +50,7 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          return unless mattr?(node) || class_attr?(node) ||
-                        singleton_attr?(node)
+          return unless mattr?(node) || (!class_attribute_allowed? && class_attr?(node)) || singleton_attr?(node)
 
           add_offense(node)
         end
@@ -74,6 +73,10 @@ module RuboCop
 
           false
         end
+
+        def class_attribute_allowed?
+          cop_config['ActiveSupportClassAttributeAllowed']
+        end
       end
     end
   end

data/lib/rubocop/cop/thread_safety/{instance_variable_in_class_method.rb → class_instance_variable.rb}

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module ThreadSafety
-      # Avoid instance variables in class methods.
+      # Avoid class instance variables.
       #
       # @example
       #   # bad
@@ -61,8 +61,8 @@ module RuboCop
       #
       #     module_function :test
       #   end
-      class InstanceVariableInClassMethod < Base
-        MSG = 'Avoid instance variables in class methods.'
+      class ClassInstanceVariable < Base
+        MSG = 'Avoid class instance variables.'
         RESTRICT_ON_SEND = %i[
           instance_variable_set
           instance_variable_get
@@ -99,21 +99,28 @@ module RuboCop
         private
 
         def class_method_definition?(node)
-          return false if method_definition?(node)
-
           in_defs?(node) ||
             in_def_sclass?(node) ||
             in_def_class_methods?(node) ||
             in_def_module_function?(node) ||
+            in_class_eval?(node) ||
             singleton_method_definition?(node)
         end
 
         def in_defs?(node)
-          node.ancestors.any?(&:defs_type?)
+          node.ancestors.any? do |ancestor|
+            break false if new_lexical_scope?(ancestor)
+
+            ancestor.defs_type?
+          end
         end
 
         def in_def_sclass?(node)
-          defn = node.ancestors.find(&:def_type?)
+          defn = node.ancestors.find do |ancestor|
+            break if new_lexical_scope?(ancestor)
+
+            ancestor.def_type?
+          end
 
           defn&.ancestors&.any?(&:sclass_type?)
         end
@@ -124,35 +131,51 @@ module RuboCop
 
         def in_def_class_methods_dsl?(node)
           node.ancestors.any? do |ancestor|
+            break if new_lexical_scope?(ancestor)
             next unless ancestor.block_type?
-            next unless ancestor.children.first.is_a? AST::SendNode
 
             ancestor.children.first.command? :class_methods
           end
         end
 
         def in_def_class_methods_module?(node)
-          defn = node.ancestors.find(&:def_type?)
-          return unless defn
+          defn = node.ancestors.find do |ancestor|
+            break if new_lexical_scope?(ancestor)
+
+            ancestor.def_type?
+          end
+          return false unless defn
 
           mod = defn.ancestors.find do |ancestor|
             %i[class module].include?(ancestor.type)
           end
-          return unless mod
+          return false unless mod
 
           class_methods_module?(mod)
         end
 
         def in_def_module_function?(node)
           defn = node.ancestors.find(&:def_type?)
-          return unless defn
+          return false unless defn
 
           defn.left_siblings.any? { |sibling| module_function_bare_access_modifier?(sibling) } ||
             defn.right_siblings.any? { |sibling| module_function_for?(sibling, defn.method_name) }
         end
 
+        def in_class_eval?(node)
+          defn = node.ancestors.find do |ancestor|
+            break if ancestor.def_type? || new_lexical_scope?(ancestor)
+
+            ancestor.block_type?
+          end
+          return false unless defn
+
+          class_eval_scope?(defn)
+        end
+
         def singleton_method_definition?(node)
           node.ancestors.any? do |ancestor|
+            break if new_lexical_scope?(ancestor)
             next unless ancestor.children.first.is_a? AST::SendNode
 
             ancestor.children.first.command? :define_singleton_method
@@ -161,6 +184,7 @@ module RuboCop
 
         def method_definition?(node)
           node.ancestors.any? do |ancestor|
+            break if new_lexical_scope?(ancestor)
             next unless ancestor.children.first.is_a? AST::SendNode
 
             ancestor.children.first.command? :define_method
@@ -199,6 +223,36 @@ module RuboCop
         def_node_matcher :module_function_for?, <<~PATTERN
           (send nil? {:module_function} ({sym str} #match_name?(%1)))
         PATTERN
+
+        # @!method new_lexical_scope?(node)
+        def_node_matcher :new_lexical_scope?, <<~PATTERN
+          {
+            (block (send (const nil? :Struct) :new ...) _ ({def defs} ...))
+            (block (send (const nil? :Class) :new ...) _ ({def defs} ...))
+            (block (send (const nil? :Data) :define ...) _ ({def defs} ...))
+            (block
+              (send nil?
+                {
+                  :prepend_around_action
+                  :prepend_before_action
+                  :before_action
+                  :append_before_action
+                  :around_action
+                  :append_around_action
+                  :append_after_action
+                  :after_action
+                  :prepend_after_action
+                }
+              )
+              ...
+            )
+          }
+        PATTERN
+
+        # @!method class_eval_scope?(node)
+        def_node_matcher :class_eval_scope?, <<~PATTERN
+          (block (send (const {nil? cbase} _) {:class_eval :class_exec}) ...)
+        PATTERN
       end
     end
   end

data/lib/rubocop/cop/thread_safety/dir_chdir.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ThreadSafety
+      # Avoid using `Dir.chdir` due to its process-wide effect.
+      #
+      # @example
+      #   # bad
+      #   Dir.chdir("/var/run")
+      #
+      #   # bad
+      #   FileUtils.chdir("/var/run")
+      class DirChdir < Base
+        MESSAGE = 'Avoid using `%<module>s.%<method>s` due to its process-wide effect.'
+        RESTRICT_ON_SEND = %i[chdir cd].freeze
+
+        # @!method chdir?(node)
+        def_node_matcher :chdir?, <<~MATCHER
+          {
+            (send (const {nil? cbase} {:Dir :FileUtils}) :chdir ...)
+            (send (const {nil? cbase} :FileUtils) :cd ...)
+          }
+        MATCHER
+
+        def on_send(node)
+          chdir?(node) do
+            add_offense(
+              node,
+              message: format(MESSAGE, module: node.receiver.short_name, method: node.method_name)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/thread_safety/mutable_class_instance_variable.rb

@@ -7,7 +7,7 @@ module RuboCop
       # mutable literal (e.g. array or hash).
       #
       # It is based on Style/MutableConstant from RuboCop.
-      # See https://github.com/rubocop-hq/rubocop/blob/master/lib/rubocop/cop/style/mutable_constant.rb
+      # See https://github.com/rubocop/rubocop/blob/master/lib/rubocop/cop/style/mutable_constant.rb
       #
       # Class instance variables are a risk to threaded code as they are shared
       # between threads. A mutable object such as an array or hash may be
@@ -74,8 +74,10 @@ module RuboCop
       #   end
       class MutableClassInstanceVariable < Base
         extend AutoCorrector
+
         include FrozenStringLiteral
         include ConfigurableEnforcedStyle
+        include OperationWithThreadsafeResult
 
         MSG = 'Freeze mutable objects assigned to class instance variables.'
         FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
@@ -84,22 +86,20 @@ module RuboCop
         def on_ivasgn(node)
           return unless in_class?(node)
 
-          _, value = *node
-          on_assignment(value)
+          on_assignment(node.expression)
         end
 
         def on_or_asgn(node)
-          lhs, value = *node
-          return unless lhs&.ivasgn_type?
+          return unless node.assignment_node.ivasgn_type?
           return unless in_class?(node)
 
-          on_assignment(value)
+          on_assignment(node.expression)
         end
 
         def on_masgn(node)
           return unless in_class?(node)
 
-          mlhs, values = *node
+          mlhs, values = *node # rubocop:disable InternalAffairs/NodeDestructuring
           return unless values.array_type?
 
           mlhs.to_a.zip(values.to_a).each do |lhs, value|
@@ -183,7 +183,7 @@ module RuboCop
         end
 
         def mutable_literal?(node)
-          return if node.nil?
+          return false if node.nil?
 
           node.mutable_literal? || range_type?(node)
         end
@@ -243,39 +243,6 @@ module RuboCop
           }
         PATTERN
 
-        # @!method operation_produces_threadsafe_object?(node)
-        def_node_matcher :operation_produces_threadsafe_object?, <<~PATTERN
-          {
-            (send (const {nil? cbase} :Queue) :new ...)
-            (send
-              (const (const {nil? cbase} :ThreadSafe) {:Hash :Array})
-              :new ...)
-            (block
-              (send
-                (const (const {nil? cbase} :ThreadSafe) {:Hash :Array})
-                :new ...)
-              ...)
-            (send (const (const {nil? cbase} :Concurrent) _) :new ...)
-            (block
-              (send (const (const {nil? cbase} :Concurrent) _) :new ...)
-              ...)
-            (send (const (const (const {nil? cbase} :Concurrent) _) _) :new ...)
-            (block
-              (send
-                (const (const (const {nil? cbase} :Concurrent) _) _)
-                :new ...)
-              ...)
-            (send
-              (const (const (const (const {nil? cbase} :Concurrent) _) _) _)
-              :new ...)
-            (block
-              (send
-                (const (const (const (const {nil? cbase} :Concurrent) _) _) _)
-                :new ...)
-              ...)
-          }
-        PATTERN
-
         # @!method range_enclosed_in_parentheses?(node)
         def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
           (begin ({irange erange} _ _))

data/lib/rubocop/cop/thread_safety/new_thread.rb

@@ -12,17 +12,15 @@ module RuboCop
       #   Thread.new { do_work }
       class NewThread < Base
         MSG = 'Avoid starting new threads.'
-        RESTRICT_ON_SEND = %i[new].freeze
+        RESTRICT_ON_SEND = %i[new fork start].freeze
 
         # @!method new_thread?(node)
         def_node_matcher :new_thread?, <<~MATCHER
-          (send (const {nil? cbase} :Thread) :new)
+          (send (const {nil? cbase} :Thread) {:new :fork :start} ...)
         MATCHER
 
         def on_send(node)
-          return unless new_thread?(node)
-
-          add_offense(node)
+          new_thread?(node) { add_offense(node) }
         end
       end
     end

data/lib/rubocop/cop/thread_safety/rack_middleware_instance_variable.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ThreadSafety
+      # Avoid instance variables in rack middleware.
+      #
+      # Middlewares are initialized once, meaning any instance variables are shared between executor threads.
+      # To avoid potential race conditions, it's recommended to design middlewares to be stateless
+      # or to implement proper synchronization mechanisms.
+      #
+      # @example
+      #   # bad
+      #   class CounterMiddleware
+      #     def initialize(app)
+      #       @app = app
+      #       @counter = 0
+      #     end
+      #
+      #     def call(env)
+      #       app.call(env)
+      #     ensure
+      #       @counter += 1
+      #     end
+      #   end
+      #
+      #   # good
+      #   class CounterMiddleware
+      #     def initialize(app)
+      #       @app = app
+      #       @counter = Concurrent::AtomicReference.new(0)
+      #     end
+      #
+      #     def call(env)
+      #       app.call(env)
+      #     ensure
+      #       @counter.update { |ref| ref + 1 }
+      #     end
+      #   end
+      #
+      #   class IdentityMiddleware
+      #     def initialize(app)
+      #       @app = app
+      #     end
+      #
+      #     def call(env)
+      #       app.call(env)
+      #     end
+      #   end
+      class RackMiddlewareInstanceVariable < Base
+        include AllowedIdentifiers
+        include OperationWithThreadsafeResult
+
+        MSG = 'Avoid instance variables in Rack middleware.'
+
+        RESTRICT_ON_SEND = %i[instance_variable_get instance_variable_set].freeze
+
+        # @!method rack_middleware_like_class?(node)
+        def_node_matcher :rack_middleware_like_class?, <<~MATCHER
+          (class (const nil? _) nil? (begin <(def :initialize (args (arg _)+) ...) (def :call (args (arg _)) ...) ...>))
+        MATCHER
+
+        # @!method app_variable(node)
+        def_node_search :app_variable, <<~MATCHER
+          (def :initialize (args (arg $_) ...) `(ivasgn $_ (lvar $_)))
+        MATCHER
+
+        def on_class(node)
+          return unless rack_middleware_like_class?(node)
+
+          constructor_method = find_constructor_method(node)
+          return unless (application_variable = extract_application_variable_from_contructor_method(constructor_method))
+
+          safe_variables = extract_safe_variables_from_constructor_method(constructor_method)
+
+          node.each_node(:def) do |def_node|
+            def_node.each_node(:ivasgn, :ivar) do |ivar_node|
+              variable, = ivar_node.to_a
+              if variable == application_variable || safe_variables.include?(variable) || allowed_identifier?(variable)
+                next
+              end
+
+              add_offense ivar_node
+            end
+          end
+        end
+
+        def on_send(node)
+          argument = node.first_argument
+
+          return unless argument&.sym_type? || argument&.str_type?
+          return if allowed_identifier?(argument.value)
+
+          add_offense node
+        end
+
+        private
+
+        def find_constructor_method(class_node)
+          class_node
+            .each_node(:def)
+            .find { |node| node.method?(:initialize) && node.arguments.size >= 1 }
+        end
+
+        def extract_application_variable_from_contructor_method(constructor_method)
+          constructor_method
+            .then { |node| app_variable(node) }
+            .then { |variables| variables.first[1] if variables.first }
+        end
+
+        def extract_safe_variables_from_constructor_method(constructor_method)
+          constructor_method
+            .each_node(:ivasgn)
+            .select { |ivasgn_node| operation_produces_threadsafe_object?(ivasgn_node.to_a[1]) }
+            .map { _1.to_a[0] }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/thread_safety/inject.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# The original code is from https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
-# See https://github.com/rubocop-hq/rubocop-rspec/blob/master/MIT_LICENSE.md
+# The original code is from https://github.com/rubocop/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
+# See https://github.com/rubocop/rubocop-rspec/blob/master/MIT-LICENSE.md
 module RuboCop
   module ThreadSafety
     # Because RuboCop doesn't yet support plugins, we have to monkey patch in a

data/lib/rubocop/thread_safety/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module ThreadSafety
-    VERSION = '0.5.1'
+    VERSION = '0.6.0'
   end
 end

data/lib/rubocop/thread_safety.rb

@@ -8,5 +8,7 @@ module RuboCop
     CONFIG = YAML.safe_load(CONFIG_DEFAULT.read).freeze
 
     private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+
+    ::RuboCop::ConfigObsoletion.files << PROJECT_ROOT.join('config', 'obsoletion.yml')
   end
 end

data/lib/rubocop-thread_safety.rb

@@ -8,7 +8,11 @@ require 'rubocop/thread_safety/inject'
 
 RuboCop::ThreadSafety::Inject.defaults!
 
-require 'rubocop/cop/thread_safety/instance_variable_in_class_method'
+require 'rubocop/cop/mixin/operation_with_threadsafe_result'
+
+require 'rubocop/cop/thread_safety/class_instance_variable'
 require 'rubocop/cop/thread_safety/class_and_module_attributes'
 require 'rubocop/cop/thread_safety/mutable_class_instance_variable'
 require 'rubocop/cop/thread_safety/new_thread'
+require 'rubocop/cop/thread_safety/dir_chdir'
+require 'rubocop/cop/thread_safety/rack_middleware_instance_variable'

data/rubocop-thread_safety.gemspec

@@ -22,17 +22,18 @@ Gem::Specification.new do |spec|
     f.match(%r{^(test|spec|features)/})
   end
 
+  spec.metadata = {
+    'changelog_uri' => 'https://github.com/rubocop/rubocop-thread_safety/blob/master/CHANGELOG.md',
+    'source_code_uri' => 'https://github.com/rubocop/rubocop-thread_safety',
+    'bug_tracker_uri' => 'https://github.com/rubocop/rubocop-thread_safety/issues',
+    'rubygems_mfa_required' => 'true'
+  }
+
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = '>= 2.5.0'
-
-  spec.add_runtime_dependency 'rubocop', '>= 0.90.0'
+  spec.required_ruby_version = '>= 2.7.0'
 
-  spec.add_development_dependency 'appraisal'
-  spec.add_development_dependency 'bundler', '>= 1.10', '< 3'
-  spec.add_development_dependency 'pry' unless ENV['CI']
-  spec.add_development_dependency 'rake', '>= 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_dependency 'rubocop', '>= 1.48.1'
 end

data/tasks/cops_documentation.rake

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'rubocop-thread_safety'
+require 'rubocop/cops_documentation_generator'
+require 'yard'
+
+YARD::Rake::YardocTask.new(:yard_for_generate_documentation) do |task|
+  task.files = ['lib/rubocop/cop/**/*.rb']
+  task.options = ['--no-output']
+end
+
+desc 'Generate docs of all cops departments'
+task generate_cops_documentation: :yard_for_generate_documentation do
+  deps = ['ThreadSafety']
+  CopsDocumentationGenerator.new(departments: deps).call
+end
+
+desc 'Syntax check for the documentation comments'
+task documentation_syntax_check: :yard_for_generate_documentation do
+  require 'parser/ruby31'
+
+  ok = true
+  YARD::Registry.load!
+  cops = RuboCop::Cop::Registry.global
+  cops.each do |cop|
+    examples = YARD::Registry.all(:class).find do |code_object|
+      next unless RuboCop::Cop::Badge.for(code_object.to_s) == cop.badge
+
+      break code_object.tags('example')
+    end
+
+    examples.to_a.each do |example|
+      buffer = Parser::Source::Buffer.new('<code>', 1)
+      buffer.source = example.text
+      parser = Parser::Ruby31.new(RuboCop::AST::Builder.new)
+      parser.diagnostics.all_errors_are_fatal = true
+      parser.parse(buffer)
+    rescue Parser::SyntaxError => e
+      path = example.object.file
+      puts "#{path}: Syntax Error in an example. #{e}"
+      ok = false
+    end
+  end
+  abort unless ok
+end