rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cop/offense.rb

@@ -24,7 +24,7 @@ module RuboCop
       # @return [Parser::Source::Range]
       #   the location where the violation is detected.
       #
-      # @see http://rubydoc.info/github/whitequark/parser/Parser/Source/Range
+      # @see https://www.rubydoc.info/gems/parser/Parser/Source/Range
       #   Parser::Source::Range
       attr_reader :location
 
@@ -54,36 +54,72 @@ module RuboCop
       # @api private
       attr_reader :status
 
+      # @api public
+      #
+      # @!attribute [r] corrector
+      #
+      # @return [Corrector | nil]
+      #   the autocorrection for this offense, or `nil` when not available
+      attr_reader :corrector
+
+      PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
+                                     :end_pos)
+
+      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
+
       # @api private
-      def initialize(severity, location, message, cop_name,
-                     status = :uncorrected)
+      def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists
+                     status = :uncorrected, corrector = nil)
         @severity = RuboCop::Cop::Severity.new(severity)
         @location = location
         @message = message.freeze
         @cop_name = cop_name.freeze
         @status = status
+        @corrector = corrector
         freeze
       end
 
       # @api public
       #
-      # @!attribute [r] corrected
+      # @!attribute [r] correctable?
       #
       # @return [Boolean]
-      #   whether this offense is automatically corrected.
-      def corrected
-        @status == :unsupported ? false : @status == :corrected
+      #   whether this offense can be automatically corrected via
+      #   autocorrect or a todo.
+      def correctable?
+        @status != :unsupported
+      end
+
+      # @api public
+      #
+      # @!attribute [r] corrected?
+      #
+      # @return [Boolean]
+      #   whether this offense is automatically corrected via
+      #   autocorrect or a todo.
+      def corrected?
+        @status == :corrected || @status == :corrected_with_todo
+      end
+
+      # @api public
+      #
+      # @!attribute [r] corrected_with_todo?
+      #
+      # @return [Boolean]
+      #   whether this offense is automatically disabled via a todo.
+      def corrected_with_todo?
+        @status == :corrected_with_todo
       end
-      alias corrected? corrected
 
       # @api public
       #
       # @!attribute [r] disabled?
       #
       # @return [Boolean]
-      #   whether this offense was locally disabled where it occurred
+      #   whether this offense was locally disabled with a
+      #   disable or todo where it occurred.
       def disabled?
-        @status == :disabled
+        @status == :disabled || @status == :todo
       end
 
       # @api public
@@ -99,8 +135,9 @@ module RuboCop
       # @api private
       # This is just for debugging purpose.
       def to_s
-        format('%s:%3d:%3d: %s',
-               severity.code, line, real_column, message)
+        format('%<severity>s:%3<line>d:%3<column>d: %<message>s',
+               severity: severity.code, line: line,
+               column: real_column, message: message)
       end
 
       # @api private
@@ -137,6 +174,11 @@ module RuboCop
         location.last_line
       end
 
+      # @api private
+      def last_column
+        location.last_column
+      end
+
       # @api private
       def column_range
         location.column_range
@@ -171,7 +213,7 @@ module RuboCop
 
       # @api public
       #
-      # Returns `-1`, `0` or `+1`
+      # Returns `-1`, `0`, or `+1`
       # if this offense is less than, equal to, or greater than `other`.
       #
       # @return [Integer]

data/lib/rubocop/cop/registry.rb

@@ -6,7 +6,7 @@ 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(
@@ -22,31 +22,42 @@ module RuboCop
 
     # Registry that tracks all cops by their badge and department.
     class Registry
-      def initialize(cops = [])
-        @registry    = {}
+      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
+        @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)
 
@@ -63,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
       #
@@ -89,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, shall_warn = true)
         badge = Badge.parse(name)
+        print_warning(name, path) if shall_warn && department_missing?(badge, name)
         return name if registered?(badge)
 
         potential_badges = qualify_badge(badge)
@@ -102,24 +114,67 @@ 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
-        cops.group_by(&:cop_name)
+        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)
+      def enabled(config, only = [], only_safe = false)
         select do |cop|
-          config.for_cop(cop).fetch('Enabled') || only.include?(cop.cop_name)
+          only.include?(cop.cop_name) || enabled?(cop, config, only_safe)
         end
       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
+          cop_enabled && cfg.fetch('Safe', true)
+        else
+          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
@@ -129,6 +184,7 @@ module RuboCop
       end
 
       def sort!
+        clear_enrollment_queue
         @registry = Hash[@registry.sort_by { |badge, _| badge.cop_name }]
 
         self
@@ -142,13 +198,60 @@ module RuboCop
         cops.each(&block)
       end
 
+      # @param [String] cop_name
+      # @return [Class, nil]
+      def find_by_cop_name(cop_name)
+        to_h[cop_name].first
+      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
+
       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) }
@@ -165,6 +268,7 @@ module RuboCop
       end
 
       def registered?(badge)
+        clear_enrollment_queue
         @registry.key?(badge)
       end
     end

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

@@ -12,15 +12,16 @@ module RuboCop
       #   eval(something)
       #   binding.eval(something)
       class Eval < Cop
-        MSG = 'The use of `eval` is a serious security risk.'.freeze
+        MSG = 'The use of `eval` is a serious security risk.'
 
-        def_node_matcher :eval?, <<-PATTERN
+        def_node_matcher :eval?, <<~PATTERN
           (send {nil? (send nil? :binding)} :eval $!str ...)
         PATTERN
 
         def on_send(node)
           eval?(node) do |code|
             return if code.dstr_type? && code.recursive_literal?
+
             add_offense(node, location: :selector)
           end
         end

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

@@ -15,23 +15,25 @@ module RuboCop
       # Other similar issues may apply.
       #
       # @example
-      #   # always offense
+      #   # bad
       #   JSON.load("{}")
       #   JSON.restore("{}")
       #
-      #   # no offense
+      #   # good
       #   JSON.parse("{}")
       #
       class JSONLoad < Cop
-        MSG = 'Prefer `JSON.parse` over `JSON.%s`.'.freeze
+        MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
 
-        def_node_matcher :json_load, <<-PATTERN
+        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))
+            add_offense(node,
+                        location: :selector,
+                        message: format(MSG, method: method))
           end
         end
 

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

@@ -19,16 +19,18 @@ module RuboCop
       #   Marshal.load(Marshal.dump({}))
       #
       class MarshalLoad < Cop
-        MSG = 'Avoid using `Marshal.%s`.'.freeze
+        MSG = 'Avoid using `Marshal.%<method>s`.'
 
-        def_node_matcher :marshal_load, <<-PATTERN
+        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))
+            add_offense(node,
+                        location: :selector,
+                        message: format(MSG, method: method))
           end
         end
       end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # This cop checks for the use of `Kernel#open`.
+      #
+      # `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.
+      #
+      # @example
+      #   # bad
+      #   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.'
+
+        def_node_matcher :open?, <<~PATTERN
+          (send nil? :open $!str ...)
+        PATTERN
+
+        def on_send(node)
+          open?(node) do |code|
+            return if safe?(code)
+
+            add_offense(node, location: :selector)
+          end
+        end
+
+        private
+
+        def safe?(node)
+          if simple_string?(node)
+            safe_argument?(node.str_content)
+          elsif composite_string?(node)
+            safe?(node.children.first)
+          else
+            false
+          end
+        end
+
+        def safe_argument?(argument)
+          !argument.empty? && !argument.start_with?('|')
+        end
+
+        def simple_string?(node)
+          node.str_type?
+        end
+
+        def composite_string?(node)
+          interpolated_string?(node) || concatenated_string?(node)
+        end
+
+        def interpolated_string?(node)
+          node.dstr_type?
+        end
+
+        def concatenated_string?(node)
+          node.send_type? && node.method?(:+) && node.receiver.str_type?
+        end
+      end
+    end
+  end
+end

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

@@ -16,9 +16,9 @@ module RuboCop
       #   YAML.dump("foo")
       #
       class YAMLLoad < Cop
-        MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'.freeze
+        MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'
 
-        def_node_matcher :yaml_load, <<-PATTERN
+        def_node_matcher :yaml_load, <<~PATTERN
           (send (const {nil? cbase} :YAML) :load ...)
         PATTERN
 

data/lib/rubocop/cop/severity.rb

@@ -31,9 +31,8 @@ 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

data/lib/rubocop/cop/style/access_modifier_declarations.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Access modifiers should be declared to apply to a group of methods
+      # or inline before each method, depending on configuration.
+      # EnforcedStyle config covers only method definitions.
+      # Applications of visibility methods to symbols can be controlled
+      # using AllowModifiersOnSymbols config.
+      #
+      # @example EnforcedStyle: group (default)
+      #   # bad
+      #   class Foo
+      #
+      #     private def bar; end
+      #     private def baz; end
+      #
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #
+      #     private
+      #
+      #     def bar; end
+      #     def baz; end
+      #
+      #   end
+      #
+      # @example EnforcedStyle: inline
+      #   # bad
+      #   class Foo
+      #
+      #     private
+      #
+      #     def bar; end
+      #     def baz; end
+      #
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #
+      #     private def bar; end
+      #     private def baz; end
+      #
+      #   end
+      #
+      # @example AllowModifiersOnSymbols: true
+      #   # good
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
+      #
+      # @example AllowModifiersOnSymbols: false
+      #   # bad
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
+      class AccessModifierDeclarations < Cop
+        include ConfigurableEnforcedStyle
+
+        GROUP_STYLE_MESSAGE = [
+          '`%<access_modifier>s` should not be',
+          'inlined in method definitions.'
+        ].join(' ')
+
+        INLINE_STYLE_MESSAGE = [
+          '`%<access_modifier>s` should be',
+          'inlined in method definitions.'
+        ].join(' ')
+
+        def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
+          (send nil? {:private :protected :public} (sym _))
+        PATTERN
+
+        def on_send(node)
+          return unless node.access_modifier?
+          return if node.parent.pair_type?
+          return if cop_config['AllowModifiersOnSymbols'] &&
+                    access_modifier_with_symbol?(node)
+
+          if offense?(node)
+            add_offense(node, location: :selector) do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def offense?(node)
+          (group_style? && access_modifier_is_inlined?(node)) ||
+            (inline_style? && access_modifier_is_not_inlined?(node))
+        end
+
+        def group_style?
+          style == :group
+        end
+
+        def inline_style?
+          style == :inline
+        end
+
+        def access_modifier_is_inlined?(node)
+          node.arguments.any?
+        end
+
+        def access_modifier_is_not_inlined?(node)
+          !access_modifier_is_inlined?(node)
+        end
+
+        def message(node)
+          access_modifier = node.loc.selector.source
+
+          if group_style?
+            format(GROUP_STYLE_MESSAGE, access_modifier: access_modifier)
+          elsif inline_style?
+            format(INLINE_STYLE_MESSAGE, access_modifier: access_modifier)
+          end
+        end
+      end
+    end
+  end
+end