rubocop-thread_safety 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33c8f2c01aa5f51c5ae09093a3ebb895a764330600ef32c05995836891cc1bd2
-  data.tar.gz: 5d4bc3124aff9203407cb61b000564084962e0ad18d72fff954d0994eb944276
+  metadata.gz: d2f9c0ded508d65e482cd339fc6bafe4a843f19982884ea8c03aa0f6ceb1f4cd
+  data.tar.gz: bcfb88db93ee4c0bacdb1df6e60e72bdd044209ecd1c9c27fc8b8e8597f5eff9
 SHA512:
-  metadata.gz: 130074abe1ba664fad05877bf2f215ed6965a8da36a92ba8865d05305c1f3661d9f2acfe67836620446c43bee81b3819111c764f37cbe2506474de3b0597de87
-  data.tar.gz: ed769cdad040ba59dba88a68af2cadbf04e3eaedd1c389261050cd0917ec4a629b775798c20d3e893650796deea250dc01c80c05a32d5c2c19151fd9d88667d0
+  metadata.gz: 81a037e33675b2aa5cf77bad8732b43e4b09bcbb0fc1127fe64eda0481516a20068e70f3afd32d4a69673729c8ce68422374b81ad7788a9de6bbe0ab9d4ae4bd
+  data.tar.gz: e6c0c3e2626e371eaf47b7fc144eb7659661d98184c47e2002d49a3f276e744f6ebc67c932fa361ff4379e536322d775579303b51e0dcf806907e9e712e61532

data/.rubocop.yml

@@ -5,6 +5,12 @@ Metrics/BlockLength:
   Exclude:
     - "spec/**/*"
 
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 14
+
 Naming/FileName:
   Exclude:
     - lib/rubocop-thread_safety.rb

data/README.md

@@ -34,6 +34,10 @@ 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.
+
 ## 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.

data/config/default.yml

@@ -0,0 +1,30 @@
+# 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.

data/lib/rubocop-thread_safety.rb

@@ -2,8 +2,13 @@
 
 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/lib/rubocop/cop/thread_safety/class_and_module_attributes.rb

@@ -27,8 +27,21 @@ module RuboCop
             ...)
         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
@@ -36,7 +49,8 @@ module RuboCop
         private
 
         def singleton_attr?(node)
-          attr?(node) && node.ancestors.map(&:type).include?(:sclass)
+          (attr?(node) || attr_internal?(node)) &&
+            node.ancestors.map(&:type).include?(:sclass)
         end
       end
     end

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

@@ -13,9 +13,33 @@ 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
       class InstanceVariableInClassMethod < Cop
         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)
           return if synchronized?(node)
@@ -24,6 +48,14 @@ 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)
@@ -64,6 +96,10 @@ module RuboCop
             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
       end
     end
   end

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

@@ -0,0 +1,227 @@
+# 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 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)
+          node&.mutable_literal?
+        end
+
+        def immutable_literal?(node)
+          node.nil? || node.immutable_literal?
+        end
+
+        def frozen_string_literal?(node)
+          FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
+            frozen_string_literals_enabled?
+        end
+
+        def requires_parentheses?(node)
+          node.range_type? ||
+            (node.send_type? && node.loc.dot.nil?)
+        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? :Struct) :new ...)
+            (block (send (const nil? :Struct) :new ...) ...)
+            (send _ :freeze)
+            (send {float int} {:+ :- :* :** :/ :% :<<} _)
+            (send _ {:+ :- :* :** :/ :%} {float int})
+            (send _ {:== :=== :!= :<= :>= :< :>} _)
+            (send (const nil? :ENV) :[] _)
+            (or (send (const nil? :ENV) :[] _) _)
+            (send _ {:count :length :size} ...)
+            (block (send _ {:count :length :size} ...) ...)
+          }
+        PATTERN
+
+        def_node_matcher :range_enclosed_in_parentheses?, <<-PATTERN
+          (begin ({irange erange} _ _))
+        PATTERN
+      end
+    end
+  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/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

@@ -2,6 +2,6 @@
 
 module RuboCop
   module ThreadSafety
-    VERSION = '0.4.0'
+    VERSION = '0.4.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-thread_safety
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Michael Gee
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-22 00:00:00.000000000 Z
+date: 2020-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -119,10 +119,14 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- config/default.yml
 - 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