rubocop-thread_safety 0.4.4 → 0.7.2

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

@@ -3,11 +3,11 @@
 module RuboCop
   module Cop
     module ThreadSafety
-      # This cop checks whether some class instance variable isn't a
+      # Checks whether some class instance variable isn't a
       # 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
@@ -72,9 +72,12 @@ module RuboCop
       #       end
       #     end.freeze
       #   end
-      class MutableClassInstanceVariable < Cop
+      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
@@ -83,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|
@@ -108,23 +109,21 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           expr = node.source_range
 
-          lambda do |corrector|
-            splat_value = splat_value(node)
-            if splat_value
-              correct_splat_expansion(corrector, expr, splat_value)
-            elsif node.array_type? && !node.bracketed?
-              corrector.insert_before(expr, '[')
-              corrector.insert_after(expr, ']')
-            elsif requires_parentheses?(node)
-              corrector.insert_before(expr, '(')
-              corrector.insert_after(expr, ')')
-            end
-
-            corrector.insert_after(expr, '.freeze')
+          splat_value = splat_value(node)
+          if splat_value
+            correct_splat_expansion(corrector, expr, splat_value)
+          elsif node.array_type? && !node.bracketed?
+            corrector.insert_before(expr, '[')
+            corrector.insert_after(expr, ']')
+          elsif requires_parentheses?(node)
+            corrector.insert_before(expr, '(')
+            corrector.insert_after(expr, ')')
           end
+
+          corrector.insert_after(expr, '.freeze')
         end
 
         private
@@ -152,7 +151,9 @@ module RuboCop
           return if operation_produces_threadsafe_object?(value)
           return if frozen_string_literal?(value)
 
-          add_offense(value)
+          add_offense(value) do |corrector|
+            autocorrect(corrector, value)
+          end
         end
 
         def check(value)
@@ -160,7 +161,9 @@ module RuboCop
                         range_enclosed_in_parentheses?(value)
           return if frozen_string_literal?(value)
 
-          add_offense(value)
+          add_offense(value) do |corrector|
+            autocorrect(corrector, value)
+          end
         end
 
         def in_class?(node)
@@ -174,12 +177,13 @@ module RuboCop
 
         def container?(node)
           return true if define_singleton_method?(node)
+          return true if define_method?(node)
 
           %i[def defs class module].include?(node.type)
         end
 
         def mutable_literal?(node)
-          return if node.nil?
+          return false if node.nil?
 
           node.mutable_literal? || range_type?(node)
         end
@@ -194,7 +198,7 @@ module RuboCop
         end
 
         def range_type?(node)
-          node.erange_type? || node.irange_type?
+          node.type?(:range)
         end
 
         def correct_splat_expansion(corrector, expr, splat_value)
@@ -205,16 +209,24 @@ module RuboCop
           end
         end
 
+        # @!method define_singleton_method?(node)
         def_node_matcher :define_singleton_method?, <<~PATTERN
           (block (send nil? :define_singleton_method ...) ...)
         PATTERN
 
+        # @!method define_method?(node)
+        def_node_matcher :define_method?, <<~PATTERN
+          (block (send nil? :define_method ...) ...)
+        PATTERN
+
+        # @!method splat_value(node)
         def_node_matcher :splat_value, <<~PATTERN
           (array (splat $_))
         PATTERN
 
         # NOTE: Some of these patterns may not actually return an immutable
         # object but we will consider them immutable for this cop.
+        # @!method operation_produces_immutable_object?(node)
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (const _ _)
@@ -231,40 +243,9 @@ module RuboCop
           }
         PATTERN
 
-        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} _ _))
+          (begin (range _ _))
         PATTERN
       end
     end

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

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

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

@@ -0,0 +1,121 @@
+# 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&.type?(:sym, :str)
+          return if allowed_identifier?(argument.value)
+
+          add_offense node
+        end
+        alias on_csend on_send
+
+        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/plugin.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module ThreadSafety
+    # A plugin that integrates RuboCop ThreadSafety with RuboCop's plugin system.
+    class Plugin < LintRoller::Plugin
+      # :nocov:
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-thread_safety',
+          version: Version::STRING,
+          homepage: 'https://github.com/rubocop/rubocop-thread_safety',
+          description: 'Thread-safety checks via static analysis.'
+        )
+      end
+      # :nocov:
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        project_root = Pathname.new(__dir__).join('../../..')
+
+        obsoletion = project_root.join('config', 'obsoletion.yml')
+        ConfigObsoletion.files << obsoletion
+
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: project_root.join('config/default.yml')
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/thread_safety/version.rb

@@ -2,6 +2,8 @@
 
 module RuboCop
   module ThreadSafety
-    VERSION = '0.4.4'
+    module Version
+      STRING = '0.7.2'
+    end
   end
 end

data/lib/rubocop/thread_safety.rb

@@ -3,10 +3,5 @@
 module RuboCop
   # RuboCop::ThreadSafety detects some potential thread safety issues.
   module ThreadSafety
-    PROJECT_ROOT = Pathname.new(File.expand_path('../../', __dir__))
-    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
-    CONFIG = YAML.safe_load(CONFIG_DEFAULT.read).freeze
-
-    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
   end
 end

data/lib/rubocop-thread_safety.rb

@@ -4,11 +4,13 @@ require 'rubocop'
 
 require 'rubocop/thread_safety'
 require 'rubocop/thread_safety/version'
-require 'rubocop/thread_safety/inject'
+require 'rubocop/thread_safety/plugin'
 
-RuboCop::ThreadSafety::Inject.defaults!
+require 'rubocop/cop/mixin/operation_with_threadsafe_result'
 
-require 'rubocop/cop/thread_safety/instance_variable_in_class_method'
+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'

metadata

@@ -1,105 +1,48 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-thread_safety
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.7.2
 platform: ruby
 authors:
 - Michael Gee
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-10 00:00:00.000000000 Z
+date: 2025-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: lint_roller
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.53.0
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.53.0
-- !ruby/object:Gem::Dependency
-  name: appraisal
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.10'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.10'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
+        version: '1.72'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
+        version: 1.72.1
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+        version: '1.72'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 1.72.1
 description: |2
       Thread-safety checks via static analysis.
       A plugin for the RuboCop code style enforcing & linting tool.
@@ -109,36 +52,31 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".rubocop.yml"
-- ".travis.yml"
-- Appraisals
-- Gemfile
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
-- Rakefile
-- bin/console
-- bin/setup
 - config/default.yml
-- gemfiles/rubocop_0.53.gemfile
-- gemfiles/rubocop_0.81.gemfile
-- gemfiles/rubocop_0.86.gemfile
-- gemfiles/rubocop_1.20.gemfile
+- config/obsoletion.yml
 - lib/rubocop-thread_safety.rb
+- lib/rubocop/cop/mixin/operation_with_threadsafe_result.rb
 - lib/rubocop/cop/thread_safety/class_and_module_attributes.rb
-- lib/rubocop/cop/thread_safety/instance_variable_in_class_method.rb
+- lib/rubocop/cop/thread_safety/class_instance_variable.rb
+- lib/rubocop/cop/thread_safety/dir_chdir.rb
 - lib/rubocop/cop/thread_safety/mutable_class_instance_variable.rb
 - lib/rubocop/cop/thread_safety/new_thread.rb
+- lib/rubocop/cop/thread_safety/rack_middleware_instance_variable.rb
 - lib/rubocop/thread_safety.rb
-- lib/rubocop/thread_safety/inject.rb
+- lib/rubocop/thread_safety/plugin.rb
 - lib/rubocop/thread_safety/version.rb
-- rubocop-thread_safety.gemspec
-homepage: https://github.com/covermymeds/rubocop-thread_safety
+homepage: https://github.com/rubocop/rubocop-thread_safety
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+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'
+  default_lint_roller_plugin: RuboCop::ThreadSafety::Plugin
 rdoc_options: []
 require_paths:
 - lib
@@ -146,15 +84,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Thread-safety checks via static analysis
 test_files: []

data/.gitignore

@@ -1,10 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/gemfiles/*.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/

data/.rspec

@@ -1,2 +0,0 @@
---color
---require spec_helper