rubocop-thread_safety 0.3.4 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8a02cd99185995c9ca8f553177ed0036e4dc8c4c
-  data.tar.gz: 2008714ed96b7a96406062af5e11d89842eb2e1d
+SHA256:
+  metadata.gz: 660c4521fd4055a7a13af1cebe1d9e53131dcdc668ff8f76e121337fda376aec
+  data.tar.gz: 8d1e6713ce9d79d70ec461b547018b29b651cbbf25d5176741d21841c9b6eee0
 SHA512:
-  metadata.gz: '0982b0a820e6d58d183c01f42ff8da9d5071bb02ee0c2fc16bf81c9efa52d16b8a928ca265bcf00397ca1f49fe99132949fb8e7c43907f7441644ad25c3a7f31'
-  data.tar.gz: 16d36ef00a8eb2010431f968521702f934d4163c97c33a68fd236f2025e41c05a6ef70c1ae80f7e2202a53356539d5cfdf7e37085d6c12d360922dd577a40193
+  metadata.gz: 715c83c5a8b65e8ea4ff968c106f4e067457e88a4e8d2fe3849b6d8361c2007f7dfcc1c1b0f5bbb0051c6311519ade6f3b7bddc1598348dd31fee58e7d3ea4d6
+  data.tar.gz: 33f0bd084a199b296baf3b03ba2cc8224eab161ebc821dd7052242eb62d649a084209fe73e2b26f08dddd7dfd907d6e69a73f153453b32618a4f8ad1f30df412

data/.gitignore

@@ -1,6 +1,7 @@
 /.bundle/
 /.yardoc
 /Gemfile.lock
+/gemfiles/*.lock
 /_yardoc/
 /coverage/
 /doc/

data/.rubocop.yml

@@ -1,15 +1,23 @@
 AllCops:
   DisplayCopNames: true
-  Include:
-    - Gemfile
-    - Rakefile
-  Exclude:
-    - vendor/**/*
+  TargetRubyVersion: 2.3
+
+Lint/RaiseException:
+  Enabled: true
+
+Lint/StructNewOverride:
+  Enabled: true
 
 Metrics/BlockLength:
   Exclude:
     - "spec/**/*"
 
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 14
+
 Naming/FileName:
   Exclude:
     - lib/rubocop-thread_safety.rb
@@ -23,6 +31,19 @@ Style/AutoResourceCleanup:
 Style/CollectionMethods:
   Enabled: true
 
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - "gemfiles/*.gemfile"
+
+Style/HashEachMethods:
+  Enabled: true
+
+Style/HashTransformKeys:
+  Enabled: false
+
+Style/HashTransformValues:
+  Enabled: false
+
 Style/MethodCalledOnDoEndBlock:
   Enabled: true
   Exclude:
@@ -38,6 +59,10 @@ Style/OptionHash:
 Style/Send:
   Enabled: true
 
+Style/StringLiterals:
+  Exclude:
+    - "gemfiles/*.gemfile"
+
 Style/StringMethods:
   Enabled: true
 

data/.travis.yml

@@ -1,19 +1,64 @@
-sudo: false
 cache: bundler
 language: ruby
 rvm:
-  - jruby-9.1.14.0
-  - 2.1
-  - 2.2
+  - jruby-9.2.9.0
   - 2.3.0
   - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
+  - 3.0
 
-matrix:
+gemfile:
+  - gemfiles/rubocop_0.53.gemfile
+  - gemfiles/rubocop_0.81.gemfile
+  - gemfiles/rubocop_0.86.gemfile
+  - gemfiles/rubocop_1.20.gemfile
+
+script_rubocop: &script_rubocop
+  - bundle exec rspec
+  - bundle exec rubocop
+
+jobs:
   fast_finish: true
+  exclude:
+  - rvm: 2.3.0
+    gemfile: gemfiles/rubocop_0.86.gemfile
+  - rvm: 2.3.0
+    gemfile: gemfiles/rubocop_1.20.gemfile
+  - rvm: 2.5
+    gemfile: gemfiles/rubocop_0.53.gemfile
+  - rvm: 2.6
+    gemfile: gemfiles/rubocop_0.53.gemfile
+  - rvm: 2.7
+    gemfile: gemfiles/rubocop_0.53.gemfile
+  - rvm: 3.0
+    gemfile: gemfiles/rubocop_0.53.gemfile
+  include:
+  - rvm: jruby-9.2.9.0
+    gemfile: gemfiles/rubocop_0.81.gemfile
+    script: *script_rubocop
+  - rvm: 2.3.0
+    gemfile: gemfiles/rubocop_0.81.gemfile
+    script: *script_rubocop
+  - rvm: 2.4
+    gemfile: gemfiles/rubocop_0.81.gemfile
+    script: *script_rubocop
+  - rvm: 2.5
+    gemfile: gemfiles/rubocop_0.81.gemfile
+    script: *script_rubocop
+  - rvm: 2.6
+    gemfile: gemfiles/rubocop_0.81.gemfile
+    script: *script_rubocop
+  - rvm: 2.7
+    gemfile: gemfiles/rubocop_0.81.gemfile
+    script: *script_rubocop
+  - rvm: 3.0
+    gemfile: gemfiles/rubocop_0.81.gemfile
+    script: *script_rubocop
 
 before_install: gem install --remote bundler
 install:
   - bundle install --retry=3
 script:
   - bundle exec rspec
-  - bundle exec rubocop

data/Appraisals

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+appraise 'rubocop-0.53' do
+  gem 'rubocop', '~> 0.53.0'
+end
+
+appraise 'rubocop-0.81' do
+  gem 'rubocop', '~> 0.81.0'
+end
+
+if Gem::Requirement.new('>= 2.4.0')
+                   .satisfied_by?(Gem::Version.new(RUBY_VERSION))
+  appraise 'rubocop-0.86' do
+    gem 'rubocop', '~> 0.86.0'
+  end
+end
+
+if Gem::Requirement.new('>= 2.5.0')
+                   .satisfied_by?(Gem::Version.new(RUBY_VERSION))
+  appraise 'rubocop-1.20' do
+    gem 'rubocop', '~> 1.20.0'
+  end
+end

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rubocop-thread_safety.gemspec

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright 2016-2017 CoverMyMeds
+Copyright 2016-2021 CoverMyMeds
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

data/README.md

@@ -34,6 +34,32 @@ Scan the application for just thread-safety issues:
 
     $ rubocop -r rubocop-thread_safety --only ThreadSafety,Style/GlobalVars,Style/ClassVars,Style/MutableConstant
 
+### Configuration
+
+There are some added [configuration options](https://github.com/covermymeds/rubocop-thread_safety/blob/master/config/default.yml) that can be tweaked to modify the behaviour of these thread-safety cops.
+
+### Correcting code for thread-safety
+
+There are a few ways to improve thread-safety that stem around avoiding
+unsynchronized mutation of state that is shared between multiple threads.
+
+State shared between threads may take various forms, including:
+
+* Class variables (`@@name`). Note: these affect child classes too.
+* Class instance variables (`@name` in class context or class methods)
+* Constants (`NAME`). Ruby will warn if a constant is re-assigned to a new value but will allow it. Mutable objects can still be mutated (e.g. push to an array) even if they are assigned to a constant.
+* Globals (`$name`), with the possible exception of some special globals provided by ruby that are documented as thread-local like regular expression results.
+* Variables in the scope of created threads (where `Thread.new` is called).
+
+Improvements that would make shared state thread-safe include:
+
+* `freeze` objects to protect against mutation. Note: `freeze` is shallow, i.e. freezing an array will not also freeze its elements.
+* Use data structures or concurrency abstractions from [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby), e.g. `Concurrent::Map`
+* Use a `Mutex` or similar to `synchronize` access.
+* Use [`ActiveSupport::CurrentAttributes`](https://api.rubyonrails.org/classes/ActiveSupport/CurrentAttributes.html)
+* Use [`RequestStore`](https://github.com/steveklabnik/request_store)
+* Use `Thread.current[:name]`
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -46,5 +72,5 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/coverm
 
 ## Copyright
 
-Copyright (c) 2016-2017 CoverMyMeds.
+Copyright (c) 2016-2021 CoverMyMeds.
 See [LICENSE.txt](LICENSE.txt) for further details.

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 

data/bin/console

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+# frozen_string_literal: true
+
 require 'bundler/setup'
 require 'rubocop-thread_safety'
 

data/config/default.yml

@@ -0,0 +1,31 @@
+# Additional configuration for thread_safety cops
+#
+# Without adding these to your rubocop config, these values will be the default.
+
+ThreadSafety/ClassAndModuleAttributes:
+  Description: 'Avoid mutating class and module attributes.'
+  Enabled: true
+
+ThreadSafety/InstanceVariableInClassMethod:
+  Description: 'Avoid using instance variables in class methods.'
+  Enabled: true
+
+ThreadSafety/MutableClassInstanceVariable:
+  Description: 'Do not assign mutable objects to class instance variables.'
+  Enabled: true
+  EnforcedStyle: literals
+  SupportedStyles:
+    # literals: freeze literals assigned to constants
+    # strict: freeze all constants
+    # Strict mode is considered an experimental feature. It has not been updated
+    # with an exhaustive list of all methods that will produce frozen objects so
+    # there is a decent chance of getting some false positives. Luckily, there is
+    # no harm in freezing an already frozen object.
+    - literals
+    - strict
+
+ThreadSafety/NewThread:
+  Description: >-
+                 Avoid starting new threads.
+                 Let a framework like Sidekiq handle the threads.
+  Enabled: true

data/gemfiles/rubocop_0.53.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rubocop", "~> 0.53.0"
+
+gemspec path: "../"

data/gemfiles/rubocop_0.81.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rubocop", "~> 0.81.0"
+
+gemspec path: "../"

data/gemfiles/rubocop_0.86.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rubocop", "~> 0.86.0"
+
+gemspec path: "../"

data/gemfiles/rubocop_1.20.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rubocop", "~> 1.20.0"
+
+gemspec path: "../"

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

@@ -13,29 +13,56 @@ module RuboCop
       #     cattr_accessor :current_user
       #   end
       class ClassAndModuleAttributes < Cop
-        MSG = 'Avoid mutating class and module attributes.'.freeze
+        MSG = 'Avoid mutating class and module attributes.'
 
-        def_node_matcher :mattr?, <<-MATCHER
+        def_node_matcher :mattr?, <<~MATCHER
           (send nil?
             {:mattr_writer :mattr_accessor :cattr_writer :cattr_accessor}
             ...)
         MATCHER
 
-        def_node_matcher :attr?, <<-MATCHER
+        def_node_matcher :attr?, <<~MATCHER
           (send nil?
             {:attr :attr_accessor :attr_writer}
             ...)
         MATCHER
 
+        def_node_matcher :attr_internal?, <<~MATCHER
+          (send nil?
+            {:attr_internal :attr_internal_accessor :attr_internal_writer}
+            ...)
+        MATCHER
+
+        def_node_matcher :class_attr?, <<~MATCHER
+          (send nil?
+            :class_attribute
+            ...)
+        MATCHER
+
         def on_send(node)
-          return unless mattr?(node) || singleton_attr?(node)
+          return unless mattr?(node) || class_attr?(node) ||
+                        singleton_attr?(node)
+
           add_offense(node, message: MSG)
         end
 
         private
 
         def singleton_attr?(node)
-          attr?(node) && node.ancestors.map(&:type).include?(:sclass)
+          (attr?(node) || attr_internal?(node)) &&
+            defined_in_singleton_class?(node)
+        end
+
+        def defined_in_singleton_class?(node)
+          node.ancestors.each do |ancestor|
+            case ancestor.type
+            when :def then return false
+            when :sclass then return true
+            else next
+            end
+          end
+
+          false
         end
       end
     end

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

@@ -13,8 +13,40 @@ module RuboCop
       #       Notifier.new(@info).deliver
       #     end
       #   end
+      #
+      #   class Model
+      #     class << self
+      #       def table_name(name)
+      #         @table_name = name
+      #       end
+      #     end
+      #   end
+      #
+      #   class Host
+      #     %i[uri port].each do |key|
+      #       define_singleton_method("#{key}=") do |value|
+      #         instance_variable_set("@#{key}", value)
+      #       end
+      #     end
+      #   end
+      #
+      #   module Example
+      #     module ClassMethods
+      #       def test(params)
+      #         @params = params
+      #       end
+      #     end
+      #   end
       class InstanceVariableInClassMethod < Cop
-        MSG = 'Avoid instance variables in class methods.'.freeze
+        MSG = 'Avoid instance variables in class methods.'
+
+        def_node_matcher :instance_variable_set_call?, <<~MATCHER
+          (send nil? :instance_variable_set (...) (...))
+        MATCHER
+
+        def_node_matcher :instance_variable_get_call?, <<~MATCHER
+          (send nil? :instance_variable_get (...))
+        MATCHER
 
         def on_ivar(node)
           return unless class_method_definition?(node)
@@ -24,11 +56,20 @@ module RuboCop
         end
         alias on_ivasgn on_ivar
 
+        def on_send(node)
+          return unless instance_variable_call?(node)
+          return unless class_method_definition?(node)
+          return if synchronized?(node)
+
+          add_offense(node, message: MSG)
+        end
+
         private
 
         def class_method_definition?(node)
           in_defs?(node) ||
             in_def_sclass?(node) ||
+            in_def_class_methods?(node) ||
             singleton_method_definition?(node)
         end
 
@@ -43,14 +84,27 @@ module RuboCop
             ancestor.type == :def
           end
 
-          defn && defn.ancestors.any? do |ancestor|
+          defn&.ancestors&.any? do |ancestor|
             ancestor.type == :sclass
           end
         end
 
+        def in_def_class_methods?(node)
+          defn = node.ancestors.find(&:def_type?)
+          return unless defn
+
+          mod = defn.ancestors.find do |ancestor|
+            %i[class module].include?(ancestor.type)
+          end
+          return unless mod
+
+          class_methods_module?(mod)
+        end
+
         def singleton_method_definition?(node)
           node.ancestors.any? do |ancestor|
             next unless ancestor.children.first.is_a? AST::SendNode
+
             ancestor.children.first.command? :define_singleton_method
           end
         end
@@ -58,10 +112,19 @@ module RuboCop
         def synchronized?(node)
           node.ancestors.find do |ancestor|
             next unless ancestor.block_type?
+
             s = ancestor.children.first
             s.send_type? && s.children.last == :synchronize
           end
         end
+
+        def instance_variable_call?(node)
+          instance_variable_set_call?(node) || instance_variable_get_call?(node)
+        end
+
+        def_node_matcher :class_methods_module?, <<~PATTERN
+          (module (const _ :ClassMethods) ...)
+        PATTERN
       end
     end
   end

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

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ThreadSafety
+      # This cop 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
+      #
+      # 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
+      # updated via an attr_reader so would not be detected by the
+      # ThreadSafety/ClassAndModuleAttributes cop.
+      #
+      # Strict mode can be used to freeze all class instance variables, rather
+      # than just literals.
+      # Strict mode is considered an experimental feature. It has not been
+      # updated with an exhaustive list of all methods that will produce frozen
+      # objects so there is a decent chance of getting some false positives.
+      # Luckily, there is no harm in freezing an already frozen object.
+      #
+      # @example EnforcedStyle: literals (default)
+      #   # bad
+      #   class Model
+      #     @list = [1, 2, 3]
+      #   end
+      #
+      #   # good
+      #   class Model
+      #     @list = [1, 2, 3].freeze
+      #   end
+      #
+      #   # good
+      #   class Model
+      #     @var = <<~TESTING.freeze
+      #       This is a heredoc
+      #     TESTING
+      #   end
+      #
+      #   # good
+      #   class Model
+      #     @var = Something.new
+      #   end
+      #
+      # @example EnforcedStyle: strict
+      #   # bad
+      #   class Model
+      #     @var = Something.new
+      #   end
+      #
+      #   # bad
+      #   class Model
+      #     @var = Struct.new do
+      #       def foo
+      #         puts 1
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Model
+      #     @var = Something.new.freeze
+      #   end
+      #
+      #   # good
+      #   class Model
+      #     @var = Struct.new do
+      #       def foo
+      #         puts 1
+      #       end
+      #     end.freeze
+      #   end
+      class MutableClassInstanceVariable < Cop
+        include FrozenStringLiteral
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Freeze mutable objects assigned to class instance variables.'
+
+        def on_ivasgn(node)
+          return unless in_class?(node)
+
+          _, value = *node
+          on_assignment(value)
+        end
+
+        def on_or_asgn(node)
+          lhs, value = *node
+          return unless lhs&.ivasgn_type?
+          return unless in_class?(node)
+
+          on_assignment(value)
+        end
+
+        def on_masgn(node)
+          return unless in_class?(node)
+
+          mlhs, values = *node
+          return unless values.array_type?
+
+          mlhs.to_a.zip(values.to_a).each do |lhs, value|
+            next unless lhs.ivasgn_type?
+
+            on_assignment(value)
+          end
+        end
+
+        def autocorrect(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')
+          end
+        end
+
+        private
+
+        def on_assignment(value)
+          if style == :strict
+            strict_check(value)
+          else
+            check(value)
+          end
+        end
+
+        def strict_check(value)
+          return if immutable_literal?(value)
+          return if operation_produces_immutable_object?(value)
+          return if operation_produces_threadsafe_object?(value)
+          return if frozen_string_literal?(value)
+
+          add_offense(value)
+        end
+
+        def check(value)
+          return unless mutable_literal?(value) ||
+                        range_enclosed_in_parentheses?(value)
+          return if frozen_string_literal?(value)
+
+          add_offense(value)
+        end
+
+        def in_class?(node)
+          container = node.ancestors.find do |ancestor|
+            container?(ancestor)
+          end
+          return false if container.nil?
+
+          %i[class module].include?(container.type)
+        end
+
+        def container?(node)
+          return true if define_singleton_method?(node)
+
+          %i[def defs class module].include?(node.type)
+        end
+
+        def mutable_literal?(node)
+          return if node.nil?
+
+          node.mutable_literal? || range_type?(node)
+        end
+
+        def immutable_literal?(node)
+          node.nil? || node.immutable_literal?
+        end
+
+        def requires_parentheses?(node)
+          range_type?(node) ||
+            (node.send_type? && node.loc.dot.nil?)
+        end
+
+        def range_type?(node)
+          node.erange_type? || node.irange_type?
+        end
+
+        def correct_splat_expansion(corrector, expr, splat_value)
+          if range_enclosed_in_parentheses?(splat_value)
+            corrector.replace(expr, "#{splat_value.source}.to_a")
+          else
+            corrector.replace(expr, "(#{splat_value.source}).to_a")
+          end
+        end
+
+        def_node_matcher :define_singleton_method?, <<~PATTERN
+          (block (send nil? :define_singleton_method ...) ...)
+        PATTERN
+
+        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.
+        def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
+          {
+            (const _ _)
+            (send (const {nil? cbase} :Struct) :new ...)
+            (block (send (const {nil? cbase} :Struct) :new ...) ...)
+            (send _ :freeze)
+            (send {float int} {:+ :- :* :** :/ :% :<<} _)
+            (send _ {:+ :- :* :** :/ :%} {float int})
+            (send _ {:== :=== :!= :<= :>= :< :>} _)
+            (send (const {nil? cbase} :ENV) :[] _)
+            (or (send (const {nil? cbase} :ENV) :[] _) _)
+            (send _ {:count :length :size} ...)
+            (block (send _ {:count :length :size} ...) ...)
+          }
+        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
+
+        def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
+          (begin ({irange erange} _ _))
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -11,14 +11,15 @@ module RuboCop
       #   # bad
       #   Thread.new { do_work }
       class NewThread < Cop
-        MSG = 'Avoid starting new threads.'.freeze
+        MSG = 'Avoid starting new threads.'
 
-        def_node_matcher :new_thread?, <<-MATCHER
-          (send (const nil? :Thread) :new)
+        def_node_matcher :new_thread?, <<~MATCHER
+          (send (const {nil? cbase} :Thread) :new)
         MATCHER
 
         def on_send(node)
           return unless new_thread?(node)
+
           add_offense(node, message: MSG)
         end
       end

data/lib/rubocop/thread_safety/inject.rb

@@ -0,0 +1,20 @@
+# 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
+module RuboCop
+  module ThreadSafety
+    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+    # bit of our configuration.
+    module Inject
+      def self.defaults!
+        path = CONFIG_DEFAULT.to_s
+        hash = ConfigLoader.__send__(:load_yaml_configuration, path)
+        config = Config.new(hash, path).tap(&:make_excludes_absolute)
+        puts "configuration from \#{path}" if ConfigLoader.debug?
+        config = ConfigLoader.merge_with_default(config, path)
+        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop/thread_safety/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module RuboCop
   module ThreadSafety
-    VERSION = '0.3.4'.freeze
+    VERSION = '0.4.3'
   end
 end

data/lib/rubocop/thread_safety.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+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

@@ -1,7 +1,14 @@
+# frozen_string_literal: true
+
 require 'rubocop'
 
+require 'rubocop/thread_safety'
 require 'rubocop/thread_safety/version'
+require 'rubocop/thread_safety/inject'
+
+RuboCop::ThreadSafety::Inject.defaults!
 
 require 'rubocop/cop/thread_safety/instance_variable_in_class_method'
 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'

data/rubocop-thread_safety.gemspec

@@ -1,4 +1,6 @@
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rubocop/thread_safety/version'
 
@@ -24,10 +26,13 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'rubocop', '>= 0.51.0'
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.add_runtime_dependency 'rubocop', '>= 0.53.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.10'
+  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 'rake', '>= 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-thread_safety
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.3
 platform: ruby
 authors:
 - Michael Gee
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2017-11-30 00:00:00.000000000 Z
+date: 2021-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -16,28 +16,48 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.51.0
+        version: 0.53.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.51.0
+        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'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -56,14 +76,14 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
@@ -93,23 +113,32 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
+- Appraisals
 - Gemfile
 - 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
 - lib/rubocop-thread_safety.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/mutable_class_instance_variable.rb
 - lib/rubocop/cop/thread_safety/new_thread.rb
+- lib/rubocop/thread_safety.rb
+- lib/rubocop/thread_safety/inject.rb
 - lib/rubocop/thread_safety/version.rb
 - rubocop-thread_safety.gemspec
 homepage: https://github.com/covermymeds/rubocop-thread_safety
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -117,16 +146,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
-signing_key: 
+rubygems_version: 3.0.3.1
+signing_key:
 specification_version: 4
 summary: Thread-safety checks via static analysis
 test_files: []