rubocop 0.88.0 → 0.91.1

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

@@ -18,8 +18,9 @@ module RuboCop
       #   # okish - deep copy hack
       #   Marshal.load(Marshal.dump({}))
       #
-      class MarshalLoad < Cop
+      class MarshalLoad < Base
         MSG = 'Avoid using `Marshal.%<method>s`.'
+        RESTRICT_ON_SEND = %i[load restore].freeze
 
         def_node_matcher :marshal_load, <<~PATTERN
           (send (const {nil? cbase} :Marshal) ${:load :restore}
@@ -28,9 +29,7 @@ module RuboCop
 
         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

@@ -19,8 +19,9 @@ module RuboCop
       #   File.open(something)
       #   IO.popen(something)
       #   URI.parse(something).open
-      class Open < Cop
+      class Open < Base
         MSG = 'The use of `Kernel#open` is a serious security risk.'
+        RESTRICT_ON_SEND = %i[open].freeze
 
         def_node_matcher :open?, <<~PATTERN
           (send nil? :open $!str ...)
@@ -30,7 +31,7 @@ module RuboCop
           open?(node) do |code|
             return if safe?(code)
 
-            add_offense(node, location: :selector)
+            add_offense(node.loc.selector)
           end
         end
 

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

@@ -15,8 +15,11 @@ module RuboCop
       #   YAML.safe_load("--- foo")
       #   YAML.dump("foo")
       #
-      class YAMLLoad < Cop
+      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
           (send (const {nil? cbase} :YAML) :load ...)
@@ -24,13 +27,11 @@ module RuboCop
 
         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,7 +6,6 @@ module RuboCop
     class Severity
       include Comparable
 
-      # @api private
       NAMES = %i[refactor convention warning error fatal].freeze
 
       # @api private
@@ -22,7 +21,6 @@ module RuboCop
       #   any of `: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
@@ -37,22 +35,18 @@ module RuboCop
         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
@@ -61,12 +55,10 @@ module RuboCop
                  end
       end
 
-      # @api private
       def hash
         @name.hash
       end
 
-      # @api private
       def <=>(other)
         level <=> other.level
       end

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

@@ -62,7 +62,7 @@ module RuboCop
       #     private :bar, :baz
       #
       #   end
-      class AccessModifierDeclarations < Cop
+      class AccessModifierDeclarations < Base
         include ConfigurableEnforcedStyle
 
         GROUP_STYLE_MESSAGE = [
@@ -75,6 +75,8 @@ module RuboCop
           'inlined in method definitions.'
         ].join(' ')
 
+        RESTRICT_ON_SEND = %i[private protected public module_function].freeze
+
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
           (send nil? {:private :protected :public} (sym _))
         PATTERN
@@ -82,13 +84,10 @@ module RuboCop
         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)
+          return if cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
 
           if offense?(node)
-            add_offense(node, location: :selector) do
-              opposite_style_detected
-            end
+            add_offense(node.loc.selector) if opposite_style_detected
           else
             correct_style_detected
           end
@@ -117,8 +116,8 @@ module RuboCop
           !access_modifier_is_inlined?(node)
         end
 
-        def message(node)
-          access_modifier = node.loc.selector.source
+        def message(range)
+          access_modifier = range.source
 
           if group_style?
             format(GROUP_STYLE_MESSAGE, access_modifier: access_modifier)

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

@@ -31,9 +31,11 @@ module RuboCop
       #     attr_reader :baz
       #   end
       #
-      class AccessorGrouping < Cop
+      class AccessorGrouping < Base
         include ConfigurableEnforcedStyle
+        include RangeHelp
         include VisibilityHelp
+        extend AutoCorrector
 
         GROUPED_MSG = 'Group together all `%<accessor>s` attributes.'
         SEPARATED_MSG = 'Use one attribute per `%<accessor>s`.'
@@ -50,13 +52,27 @@ module RuboCop
         alias on_sclass on_class
         alias on_module on_class
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, correction(node))
+        private
+
+        def check(send_node)
+          return if previous_line_comment?(send_node)
+          return unless grouped_style? && sibling_accessors(send_node).size > 1 ||
+                        separated_style? && send_node.arguments.size > 1
+
+          message = message(send_node)
+          add_offense(send_node, message: message) do |corrector|
+            autocorrect(corrector, send_node)
           end
         end
 
-        private
+        def autocorrect(corrector, node)
+          if (preferred_accessors = preferred_accessors(node))
+            corrector.replace(node, preferred_accessors)
+          else
+            range = range_with_surrounding_space(range: node.loc.expression, side: :left)
+            corrector.remove(range)
+          end
+        end
 
         def previous_line_comment?(node)
           comment_line?(processed_source[node.first_line - 2])
@@ -78,16 +94,6 @@ module RuboCop
           send_node.macro? && ACCESSOR_METHODS.include?(send_node.method_name)
         end
 
-        def check(send_node)
-          return if previous_line_comment?(send_node)
-
-          if grouped_style? && sibling_accessors(send_node).size > 1
-            add_offense(send_node)
-          elsif separated_style? && send_node.arguments.size > 1
-            add_offense(send_node)
-          end
-        end
-
         def grouped_style?
           style == :grouped
         end
@@ -110,14 +116,10 @@ module RuboCop
           format(msg, accessor: send_node.method_name)
         end
 
-        def correction(node)
+        def preferred_accessors(node)
           if grouped_style?
             accessors = sibling_accessors(node)
-            if node == accessors.first
-              group_accessors(node, accessors)
-            else
-              ''
-            end
+            group_accessors(node, accessors) if node == accessors.first
           else
             separate_accessors(node)
           end

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

@@ -22,8 +22,9 @@ module RuboCop
       #
       #   # good
       #   alias_method :bar, :foo
-      class Alias < Cop
+      class Alias < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_ALIAS = 'Use `alias_method` instead of `alias`.'
         MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` ' \
@@ -31,36 +32,44 @@ module RuboCop
         MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of ' \
                            '`alias %<current>s`.'
 
+        RESTRICT_ON_SEND = %i[alias_method].freeze
+
         def on_send(node)
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)
 
           msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
-          add_offense(node, location: :selector, message: msg)
+          add_offense(node.loc.selector, message: msg) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def on_alias(node)
           return unless alias_method_possible?(node)
 
           if scope_type(node) == :dynamic || style == :prefer_alias_method
-            add_offense(node, location: :keyword, message: MSG_ALIAS)
+            add_offense(node.loc.keyword, message: MSG_ALIAS) do |corrector|
+              autocorrect(corrector, node)
+            end
           elsif node.children.none? { |arg| bareword?(arg) }
-            add_offense_for_args(node)
+            add_offense_for_args(node) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           if node.send_type?
-            correct_alias_method_to_alias(node)
+            correct_alias_method_to_alias(corrector, node)
           elsif scope_type(node) == :dynamic || style == :prefer_alias_method
-            correct_alias_to_alias_method(node)
+            correct_alias_to_alias_method(corrector, node)
           else
-            correct_alias_with_symbol_args(node)
+            correct_alias_with_symbol_args(corrector, node)
           end
         end
 
-        private
-
         def alias_keyword_possible?(node)
           scope_type(node) != :dynamic && node.arguments.all?(&:sym_type?)
         end
@@ -70,14 +79,14 @@ module RuboCop
             node.children.none?(&:gvar_type?)
         end
 
-        def add_offense_for_args(node)
+        def add_offense_for_args(node, &block)
           existing_args  = node.children.map(&:source).join(' ')
           preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
           arg_ranges     = node.children.map(&:source_range)
           msg            = format(MSG_SYMBOL_ARGS,
                                   prefer: preferred_args,
                                   current: existing_args)
-          add_offense(node, location: arg_ranges.reduce(&:join), message: msg)
+          add_offense(arg_ranges.reduce(&:join), message: msg, &block)
         end
 
         # In this expression, will `self` be the same as the innermost enclosing
@@ -101,41 +110,39 @@ module RuboCop
         end
 
         def lexical_scope_type(node)
-          node.each_ancestor(:class, :module) do |ancestor|
-            return ancestor.class_type? ? 'in a class body' : 'in a module body'
+          ancestor = node.each_ancestor(:class, :module).first
+          if ancestor.nil?
+            'at the top level'
+          elsif ancestor.class_type?
+            'in a class body'
+          else
+            'in a module body'
           end
-          'at the top level'
         end
 
         def bareword?(sym_node)
           !sym_node.source.start_with?(':')
         end
 
-        def correct_alias_method_to_alias(send_node)
-          lambda do |corrector|
-            new, old = *send_node.arguments
-            replacement = "alias #{identifier(new)} #{identifier(old)}"
-            corrector.replace(send_node, replacement)
-          end
+        def correct_alias_method_to_alias(corrector, send_node)
+          new, old = *send_node.arguments
+          replacement = "alias #{identifier(new)} #{identifier(old)}"
+
+          corrector.replace(send_node, replacement)
         end
 
-        def correct_alias_to_alias_method(node)
-          lambda do |corrector|
-            replacement =
-              'alias_method ' \
-              ":#{identifier(node.new_identifier)}, " \
-              ":#{identifier(node.old_identifier)}"
-            corrector.replace(node, replacement)
-          end
+        def correct_alias_to_alias_method(corrector, node)
+          replacement =
+            'alias_method ' \
+            ":#{identifier(node.new_identifier)}, " \
+            ":#{identifier(node.old_identifier)}"
+
+          corrector.replace(node, replacement)
         end
 
-        def correct_alias_with_symbol_args(node)
-          lambda do |corrector|
-            corrector.replace(node.new_identifier,
-                              node.new_identifier.source[1..-1])
-            corrector.replace(node.old_identifier,
-                              node.old_identifier.source[1..-1])
-          end
+        def correct_alias_with_symbol_args(corrector, node)
+          corrector.replace(node.new_identifier, node.new_identifier.source[1..-1])
+          corrector.replace(node.old_identifier, node.old_identifier.source[1..-1])
         end
 
         def_node_matcher :identifier, <<~PATTERN

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

@@ -36,9 +36,10 @@ module RuboCop
       #   # good
       #   if foo && bar
       #   end
-      class AndOr < Cop
+      class AndOr < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -55,8 +56,13 @@ module RuboCop
         alias on_until      on_if
         alias on_until_post on_if
 
-        def autocorrect(node)
-          lambda do |corrector|
+        private
+
+        def process_logical_operator(node)
+          return if node.logical_operator?
+
+          message = message(node)
+          add_offense(node.loc.operator, message: message) do |corrector|
             node.each_child_node do |expr|
               if expr.send_type?
                 correct_send(expr, corrector)
@@ -71,20 +77,12 @@ module RuboCop
           end
         end
 
-        private
-
         def on_conditionals(node)
           node.condition.each_node(*AST::Node::OPERATOR_KEYWORDS) do |operator|
             process_logical_operator(operator)
           end
         end
 
-        def process_logical_operator(node)
-          return if node.logical_operator?
-
-          add_offense(node, location: :operator)
-        end
-
         def message(node)
           format(MSG, prefer: node.alternate_operator, current: node.operator)
         end

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

@@ -17,20 +17,19 @@ module RuboCop
       #   # good
       #   %w(foo bar baz).join(",")
       #
-      class ArrayJoin < Cop
+      class ArrayJoin < Base
+        extend AutoCorrector
+
         MSG = 'Favor `Array#join` over `Array#*`.'
+        RESTRICT_ON_SEND = %i[*].freeze
 
         def_node_matcher :join_candidate?, '(send $array :* $str)'
 
         def on_send(node)
-          join_candidate?(node) { add_offense(node, location: :selector) }
-        end
-
-        def autocorrect(node)
-          array, join_arg = join_candidate?(node).map(&:source)
+          return unless (array, join_arg = join_candidate?(node))
 
-          lambda do |corrector|
-            corrector.replace(node, "#{array}.join(#{join_arg})")
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node, "#{array.source}.join(#{join_arg.source})")
           end
         end
       end