rubocop 0.66.0 → 1.25.1

data/lib/rubocop/cop/registry.rb

@@ -6,55 +6,64 @@ module RuboCop
     # refer to two or more cops under different departments
     class AmbiguousCopName < RuboCop::Error
       MSG = 'Ambiguous cop name `%<name>s` used in %<origin>s needs ' \
-            'department qualifier. Did you mean %<options>s?'.freeze
+            'department qualifier. Did you mean %<options>s?'
 
       def initialize(name, origin, badges)
         super(
-          format(
-            MSG,
-            name: name,
-            origin: origin,
-            options: badges.to_a.join(' or ')
-          )
+          format(MSG, name: name, origin: origin, options: badges.to_a.join(' or '))
         )
       end
     end
 
     # Registry that tracks all cops by their badge and department.
     class Registry
-      def initialize(cops = [])
+      include Enumerable
+
+      attr_reader :options
+
+      def initialize(cops = [], options = {})
         @registry = {}
         @departments = {}
         @cops_by_cop_name = Hash.new { |hash, key| hash[key] = [] }
 
-        cops.each { |cop| enlist(cop) }
+        @enrollment_queue = cops
+        @options = options
       end
 
       def enlist(cop)
-        @registry[cop.badge] = cop
-        @departments[cop.department] ||= []
-        @departments[cop.department] << cop
-        @cops_by_cop_name[cop.cop_name] << cop
+        @enrollment_queue << cop
+      end
+
+      def dismiss(cop)
+        raise "Cop #{cop} could not be dismissed" unless @enrollment_queue.delete(cop)
       end
 
       # @return [Array<Symbol>] list of departments for current cops.
       def departments
+        clear_enrollment_queue
         @departments.keys
       end
 
       # @return [Registry] Cops for that specific department.
       def with_department(department)
+        clear_enrollment_queue
         with(@departments.fetch(department, []))
       end
 
       # @return [Registry] Cops not for a specific department.
       def without_department(department)
+        clear_enrollment_queue
         without_department = @departments.dup
         without_department.delete(department)
 
         with(without_department.values.flatten)
       end
 
+      # @return [Boolean] Checks if given name is department
+      def department?(name)
+        departments.include? name.to_sym
+      end
+
       def contains_cop_matching?(names)
         cops.any? { |cop| cop.match?(names) }
       end
@@ -65,17 +74,17 @@ module RuboCop
       #
       #   cops = RuboCop::Cop::Cop.all
       #   cops.
-      #     qualified_cop_name('Layout/IndentArray') # => 'Layout/IndentArray'
+      #     qualified_cop_name('Layout/EndOfLine') # => 'Layout/EndOfLine'
       #
       # @example fixes incorrect namespaces
       #
       #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('Lint/IndentArray') # => 'Layout/IndentArray'
+      #   cops.qualified_cop_name('Lint/EndOfLine') # => 'Layout/EndOfLine'
       #
       # @example namespaces bare cop identifiers
       #
       #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('IndentArray') # => 'Layout/IndentArray'
+      #   cops.qualified_cop_name('EndOfLine') # => 'Layout/EndOfLine'
       #
       # @example passes back unrecognized cop names
       #
@@ -91,8 +100,9 @@ module RuboCop
       # @note Emits a warning if the provided name has an incorrect namespace
       #
       # @return [String] Qualified cop name
-      def qualified_cop_name(name, path)
+      def qualified_cop_name(name, path, warn: true)
         badge = Badge.parse(name)
+        print_warning(name, path) if warn && department_missing?(badge, name)
         return name if registered?(badge)
 
         potential_badges = qualify_badge(badge)
@@ -104,44 +114,79 @@ module RuboCop
         end
       end
 
+      def department_missing?(badge, name)
+        !badge.qualified? && unqualified_cop_names.include?(name)
+      end
+
+      def print_warning(name, path)
+        message = "#{path}: Warning: no department given for #{name}."
+        if path.end_with?('.rb')
+          message += ' Run `rubocop -a --only Migration/DepartmentName` to fix.'
+        end
+        warn message
+      end
+
+      def unqualified_cop_names
+        clear_enrollment_queue
+        @unqualified_cop_names ||=
+          Set.new(@cops_by_cop_name.keys.map { |qn| File.basename(qn) }) <<
+          'RedundantCopDisableDirective'
+      end
+
       # @return [Hash{String => Array<Class>}]
       def to_h
+        clear_enrollment_queue
         @cops_by_cop_name
       end
 
       def cops
+        clear_enrollment_queue
         @registry.values
       end
 
       def length
+        clear_enrollment_queue
         @registry.size
       end
 
-      def enabled(config, only, only_safe = false)
-        select do |cop|
-          only.include?(cop.cop_name) || enabled?(cop, config, only_safe)
-        end
+      def enabled(config, only = [], only_safe: false)
+        select { |cop| only.include?(cop.cop_name) || enabled?(cop, config, only_safe) }
       end
 
       def enabled?(cop, config, only_safe)
         cfg = config.for_cop(cop)
+
+        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
+
         if only_safe
-          cfg.fetch('Enabled') && cfg.fetch('Safe', true)
+          cop_enabled && cfg.fetch('Safe', true)
         else
-          cfg.fetch('Enabled')
+          cop_enabled
         end
       end
 
+      def enabled_pending_cop?(cop_cfg, config)
+        return false if @options[:disable_pending_cops]
+
+        cop_cfg.fetch('Enabled') == 'pending' &&
+          (@options[:enable_pending_cops] || config.enabled_new_cops?)
+      end
+
       def names
         cops.map(&:cop_name)
       end
 
+      def names_for_department(department)
+        cops.select { |cop| cop.department == department.to_sym }.map(&:cop_name)
+      end
+
       def ==(other)
         cops == other.cops
       end
 
       def sort!
-        @registry = Hash[@registry.sort_by { |badge, _| badge.cop_name }]
+        clear_enrollment_queue
+        @registry = @registry.sort_by { |badge, _| badge.cop_name }.to_h
 
         self
       end
@@ -157,16 +202,67 @@ module RuboCop
       # @param [String] cop_name
       # @return [Class, nil]
       def find_by_cop_name(cop_name)
-        @cops_by_cop_name[cop_name].first
+        to_h[cop_name].first
+      end
+
+      def freeze
+        clear_enrollment_queue
+        unqualified_cop_names # build cache
+        super
+      end
+
+      @global = new
+
+      class << self
+        attr_reader :global
+      end
+
+      def self.all
+        global.without_department(:Test).cops
+      end
+
+      def self.qualified_cop_name(name, origin)
+        global.qualified_cop_name(name, origin)
+      end
+
+      # Changes momentarily the global registry
+      # Intended for testing purposes
+      def self.with_temporary_global(temp_global = global.dup)
+        previous = @global
+        @global = temp_global
+        yield
+      ensure
+        @global = previous
+      end
+
+      def self.reset!
+        @global = new
       end
 
       private
 
+      def initialize_copy(reg)
+        initialize(reg.cops, reg.options)
+      end
+
+      def clear_enrollment_queue
+        return if @enrollment_queue.empty?
+
+        @enrollment_queue.each do |cop|
+          @registry[cop.badge] = cop
+          @departments[cop.department] ||= []
+          @departments[cop.department] << cop
+          @cops_by_cop_name[cop.cop_name] << cop
+        end
+        @enrollment_queue = []
+      end
+
       def with(cops)
         self.class.new(cops)
       end
 
       def qualify_badge(badge)
+        clear_enrollment_queue
         @departments
           .map { |department, _| badge.with_department(department) }
           .select { |potential_badge| registered?(potential_badge) }
@@ -183,6 +279,7 @@ module RuboCop
       end
 
       def registered?(badge)
+        clear_enrollment_queue
         @registry.key?(badge)
       end
     end

data/lib/rubocop/cop/security/eval.rb

@@ -11,10 +11,12 @@ module RuboCop
       #
       #   eval(something)
       #   binding.eval(something)
-      class Eval < Cop
-        MSG = 'The use of `eval` is a serious security risk.'.freeze
+      class Eval < Base
+        MSG = 'The use of `eval` is a serious security risk.'
+        RESTRICT_ON_SEND = %i[eval].freeze
 
-        def_node_matcher :eval?, <<-PATTERN
+        # @!method eval?(node)
+        def_node_matcher :eval?, <<~PATTERN
           (send {nil? (send nil? :binding)} :eval $!str ...)
         PATTERN
 
@@ -22,7 +24,7 @@ module RuboCop
           eval?(node) do |code|
             return if code.dstr_type? && code.recursive_literal?
 
-            add_offense(node, location: :selector)
+            add_offense(node.loc.selector)
           end
         end
       end

data/lib/rubocop/cop/security/io_methods.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for the first argument to `IO.read`, `IO.binread`, `IO.write`, `IO.binwrite`,
+      # `IO.foreach`, and `IO.readlines`.
+      #
+      # If argument starts with a pipe character (`'|'`) and the receiver is the `IO` class,
+      # a subprocess is created in the same way as `Kernel#open`, and its output is returned.
+      # `Kernel#open` may allow unintentional command injection, which is the reason these
+      # `IO` methods are a security risk.
+      # Consider to use `File.read` to disable the behavior of subprocess invocation.
+      #
+      # @safety
+      #   This cop is unsafe because false positive will occur if the variable passed as
+      #   the first argument is a command that is not a file path.
+      #
+      # @example
+      #
+      #   # bad
+      #   IO.read(path)
+      #   IO.read('path')
+      #
+      #   # good
+      #   File.read(path)
+      #   File.read('path')
+      #   IO.read('| command') # Allow intentional command invocation.
+      #
+      class IoMethods < Base
+        extend AutoCorrector
+
+        MSG = '`File.%<method_name>s` is safer than `IO.%<method_name>s`.'
+        RESTRICT_ON_SEND = %i[read binread write binwrite foreach readlines].freeze
+
+        def on_send(node)
+          return unless (receiver = node.receiver) && receiver.source == 'IO'
+
+          argument = node.first_argument
+          return if argument.respond_to?(:value) && argument.value.strip.start_with?('|')
+
+          add_offense(node, message: format(MSG, method_name: node.method_name)) do |corrector|
+            corrector.replace(receiver, 'File')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/security/json_load.rb

@@ -6,13 +6,14 @@ module RuboCop
       # This cop checks for the use of JSON class methods which have potential
       # security issues.
       #
-      # Autocorrect is disabled by default because it's potentially dangerous.
-      # If using a stream, like `JSON.load(open('file'))`, it will need to call
-      # `#read` manually, like `JSON.parse(open('file').read)`.
-      # If reading single values (rather than proper JSON objects), like
-      # `JSON.load('false')`, it will need to pass the `quirks_mode: true`
-      # option, like `JSON.parse('false', quirks_mode: true)`.
-      # Other similar issues may apply.
+      # @safety
+      #   This cop's autocorrection is unsafe because it's potentially dangerous.
+      #   If using a stream, like `JSON.load(open('file'))`, it will need to call
+      #   `#read` manually, like `JSON.parse(open('file').read)`.
+      #   If reading single values (rather than proper JSON objects), like
+      #   `JSON.load('false')`, it will need to pass the `quirks_mode: true`
+      #   option, like `JSON.parse('false', quirks_mode: true)`.
+      #   Other similar issues may apply.
       #
       # @example
       #   # bad
@@ -22,24 +23,24 @@ module RuboCop
       #   # good
       #   JSON.parse("{}")
       #
-      class JSONLoad < Cop
-        MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'.freeze
+      class JSONLoad < Base
+        extend AutoCorrector
 
-        def_node_matcher :json_load, <<-PATTERN
+        MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
+        RESTRICT_ON_SEND = %i[load restore].freeze
+
+        # @!method json_load(node)
+        def_node_matcher :json_load, <<~PATTERN
           (send (const {nil? cbase} :JSON) ${:load :restore} ...)
         PATTERN
 
         def on_send(node)
           json_load(node) do |method|
-            add_offense(node,
-                        location: :selector,
-                        message: format(MSG, method: method))
+            add_offense(node.loc.selector, message: format(MSG, method: method)) do |corrector|
+              corrector.replace(node.loc.selector, 'parse')
+            end
           end
         end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'parse') }
-        end
       end
     end
   end

data/lib/rubocop/cop/security/marshal_load.rb

@@ -18,19 +18,19 @@ module RuboCop
       #   # okish - deep copy hack
       #   Marshal.load(Marshal.dump({}))
       #
-      class MarshalLoad < Cop
-        MSG = 'Avoid using `Marshal.%<method>s`.'.freeze
+      class MarshalLoad < Base
+        MSG = 'Avoid using `Marshal.%<method>s`.'
+        RESTRICT_ON_SEND = %i[load restore].freeze
 
-        def_node_matcher :marshal_load, <<-PATTERN
+        # @!method marshal_load(node)
+        def_node_matcher :marshal_load, <<~PATTERN
           (send (const {nil? cbase} :Marshal) ${:load :restore}
           !(send (const {nil? cbase} :Marshal) :dump ...))
         PATTERN
 
         def on_send(node)
           marshal_load(node) do |method|
-            add_offense(node,
-                        location: :selector,
-                        message: format(MSG, method: method))
+            add_offense(node.loc.selector, message: format(MSG, method: method))
           end
         end
       end

data/lib/rubocop/cop/security/open.rb

@@ -3,34 +3,52 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of `Kernel#open`.
+      # This cop checks for the use of `Kernel#open` and `URI.open` with dynamic
+      # data.
       #
-      # `Kernel#open` enables not only file access but also process invocation
-      # by prefixing a pipe symbol (e.g., `open("| ls")`). So, it may lead to
-      # a serious security risk by using variable input to the argument of
-      # `Kernel#open`. It would be better to use `File.open`, `IO.popen` or
-      # `URI#open` explicitly.
+      # `Kernel#open` and `URI.open` enable not only file access but also process
+      # invocation by prefixing a pipe symbol (e.g., `open("| ls")`).
+      # So, it may lead to a serious security risk by using variable input to
+      # the argument of `Kernel#open` and `URI.open`. It would be better to use
+      # `File.open`, `IO.popen` or `URI.parse#open` explicitly.
+      #
+      # NOTE: `open` and `URI.open` with literal strings are not flagged by this
+      # cop.
+      #
+      # @safety
+      #   This cop could register false positives if `open` is redefined
+      #   in a class and then used without a receiver in that class.
       #
       # @example
       #   # bad
       #   open(something)
+      #   open("| #{something}")
+      #   URI.open(something)
       #
       #   # good
       #   File.open(something)
       #   IO.popen(something)
       #   URI.parse(something).open
-      class Open < Cop
-        MSG = 'The use of `Kernel#open` is a serious security risk.'.freeze
+      #
+      #   # good (literal strings)
+      #   open("foo.text")
+      #   open("| foo")
+      #   URI.open("http://example.com")
+      class Open < Base
+        MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
+        RESTRICT_ON_SEND = %i[open].freeze
 
-        def_node_matcher :open?, <<-PATTERN
-          (send nil? :open $!str ...)
+        # @!method open?(node)
+        def_node_matcher :open?, <<~PATTERN
+          (send ${nil? (const {nil? cbase} :URI)} :open $!str ...)
         PATTERN
 
         def on_send(node)
-          open?(node) do |code|
+          open?(node) do |receiver, code|
             return if safe?(code)
 
-            add_offense(node, location: :selector)
+            message = format(MSG, receiver: receiver ? "#{receiver.source}." : 'Kernel#')
+            add_offense(node.loc.selector, message: message)
           end
         end
 

data/lib/rubocop/cop/security/yaml_load.rb

@@ -7,6 +7,10 @@ module RuboCop
       # potential security issues leading to remote code execution when
       # loading from an untrusted source.
       #
+      # @safety
+      #   The behaviour of the code might change depending on what was
+      #   in the YAML payload, since `YAML.safe_load` is more restrictive.
+      #
       # @example
       #   # bad
       #   YAML.load("--- foo")
@@ -15,22 +19,24 @@ module RuboCop
       #   YAML.safe_load("--- foo")
       #   YAML.dump("foo")
       #
-      class YAMLLoad < Cop
-        MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'.freeze
+      class YAMLLoad < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'
+        RESTRICT_ON_SEND = %i[load].freeze
 
-        def_node_matcher :yaml_load, <<-PATTERN
+        # @!method yaml_load(node)
+        def_node_matcher :yaml_load, <<~PATTERN
           (send (const {nil? cbase} :YAML) :load ...)
         PATTERN
 
         def on_send(node)
           yaml_load(node) do
-            add_offense(node, location: :selector)
+            add_offense(node.loc.selector) do |corrector|
+              corrector.replace(node.loc.selector, 'safe_load')
+            end
           end
         end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'safe_load') }
-        end
       end
     end
   end

data/lib/rubocop/cop/severity.rb

@@ -6,11 +6,10 @@ module RuboCop
     class Severity
       include Comparable
 
-      # @api private
-      NAMES = %i[refactor convention warning error fatal].freeze
+      NAMES = %i[info refactor convention warning error fatal].freeze
 
       # @api private
-      CODE_TABLE = { R: :refactor, C: :convention,
+      CODE_TABLE = { I: :info, R: :refactor, C: :convention,
                      W: :warning, E: :error, F: :fatal }.freeze
 
       # @api public
@@ -19,10 +18,9 @@ module RuboCop
       #
       # @return [Symbol]
       #   severity.
-      #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+      #   any of `:info`, `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
       attr_reader :name
 
-      # @api private
       def self.name_from_code(code)
         name = code.to_sym
         CODE_TABLE[name] || name
@@ -31,30 +29,24 @@ module RuboCop
       # @api private
       def initialize(name_or_code)
         name = Severity.name_from_code(name_or_code)
-        unless NAMES.include?(name)
-          raise ArgumentError, "Unknown severity: #{name}"
-        end
+        raise ArgumentError, "Unknown severity: #{name}" unless NAMES.include?(name)
 
         @name = name.freeze
         freeze
       end
 
-      # @api private
       def to_s
         @name.to_s
       end
 
-      # @api private
       def code
         @name.to_s[0].upcase
       end
 
-      # @api private
       def level
         NAMES.index(name) + 1
       end
 
-      # @api private
       def ==(other)
         @name == if other.is_a?(Symbol)
                    other
@@ -63,12 +55,10 @@ module RuboCop
                  end
       end
 
-      # @api private
       def hash
         @name.hash
       end
 
-      # @api private
       def <=>(other)
         level <=> other.level
       end