rubocop 0.85.1 → 0.89.0

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

@@ -22,7 +22,9 @@ module RuboCop
       #   # good
       #   JSON.parse("{}")
       #
-      class JSONLoad < Cop
+      class JSONLoad < Base
+        extend AutoCorrector
+
         MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
 
         def_node_matcher :json_load, <<~PATTERN
@@ -31,15 +33,11 @@ module RuboCop
 
         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,7 +18,7 @@ module RuboCop
       #   # okish - deep copy hack
       #   Marshal.load(Marshal.dump({}))
       #
-      class MarshalLoad < Cop
+      class MarshalLoad < Base
         MSG = 'Avoid using `Marshal.%<method>s`.'
 
         def_node_matcher :marshal_load, <<~PATTERN
@@ -28,9 +28,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,7 +19,7 @@ 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.'
 
         def_node_matcher :open?, <<~PATTERN
@@ -30,7 +30,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,7 +15,9 @@ 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`.'
 
         def_node_matcher :yaml_load, <<~PATTERN
@@ -24,13 +26,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/style/access_modifier_declarations.rb

@@ -65,6 +65,8 @@ module RuboCop
       class AccessModifierDeclarations < Cop
         include ConfigurableEnforcedStyle
 
+        ACCESS_MODIFIERS = %i[private protected public module_function].to_set.freeze
+
         GROUP_STYLE_MESSAGE = [
           '`%<access_modifier>s` should not be',
           'inlined in method definitions.'
@@ -80,7 +82,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.access_modifier?
+          return unless access_modifier?(node)
           return if node.parent.pair_type?
           return if cop_config['AllowModifiersOnSymbols'] &&
                     access_modifier_with_symbol?(node)
@@ -96,6 +98,14 @@ module RuboCop
 
         private
 
+        def access_modifier?(node)
+          maybe_access_modifier?(node) && node.access_modifier?
+        end
+
+        def maybe_access_modifier?(node)
+          !node.receiver && ACCESS_MODIFIERS.include?(node.method_name)
+        end
+
         def offense?(node)
           (group_style? && access_modifier_is_inlined?(node)) ||
             (inline_style? && access_modifier_is_not_inlined?(node))

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for grouping of accessors in `class` and `module` bodies.
+      # By default it enforces accessors to be placed in grouped declarations,
+      # but it can be configured to enforce separating them in multiple declarations.
+      #
+      # @example EnforcedStyle: grouped (default)
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_reader :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :bar, :baz
+      #   end
+      #
+      # @example EnforcedStyle: separated
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar, :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_reader :baz
+      #   end
+      #
+      class AccessorGrouping < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        include VisibilityHelp
+
+        GROUPED_MSG = 'Group together all `%<accessor>s` attributes.'
+        SEPARATED_MSG = 'Use one attribute per `%<accessor>s`.'
+
+        ACCESSOR_METHODS = %i[attr_reader attr_writer attr_accessor attr].freeze
+
+        def on_class(node)
+          class_send_elements(node).each do |macro|
+            next unless accessor?(macro)
+
+            check(macro)
+          end
+        end
+        alias on_sclass on_class
+        alias on_module on_class
+
+        def autocorrect(node)
+          lambda do |corrector|
+            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
+        end
+
+        private
+
+        def previous_line_comment?(node)
+          comment_line?(processed_source[node.first_line - 2])
+        end
+
+        def class_send_elements(class_node)
+          class_def = class_node.body
+
+          if !class_def || class_def.def_type?
+            []
+          elsif class_def.send_type?
+            [class_def]
+          else
+            class_def.each_child_node(:send).to_a
+          end
+        end
+
+        def accessor?(send_node)
+          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
+
+        def separated_style?
+          style == :separated
+        end
+
+        def sibling_accessors(send_node)
+          send_node.parent.each_child_node(:send).select do |sibling|
+            accessor?(sibling) &&
+              sibling.method?(send_node.method_name) &&
+              node_visibility(sibling) == node_visibility(send_node) &&
+              !previous_line_comment?(sibling)
+          end
+        end
+
+        def message(send_node)
+          msg = grouped_style? ? GROUPED_MSG : SEPARATED_MSG
+          format(msg, accessor: send_node.method_name)
+        end
+
+        def preferred_accessors(node)
+          if grouped_style?
+            accessors = sibling_accessors(node)
+            group_accessors(node, accessors) if node == accessors.first
+          else
+            separate_accessors(node)
+          end
+        end
+
+        def group_accessors(node, accessors)
+          accessor_names = accessors.flat_map do |accessor|
+            accessor.arguments.map(&:source)
+          end
+
+          "#{node.method_name} #{accessor_names.join(', ')}"
+        end
+
+        def separate_accessors(node)
+          node.arguments.map do |arg|
+            if arg == node.arguments.first
+              "#{node.method_name} #{arg.source}"
+            else
+              indent = ' ' * node.loc.column
+              "#{indent}#{node.method_name} #{arg.source}"
+            end
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -101,10 +101,14 @@ 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)

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of `Array()` instead of explicit `Array` check or `[*var]`.
+      #
+      # @example
+      #   # bad
+      #   paths = [paths] unless paths.is_a?(Array)
+      #   paths.each { |path| do_something(path) }
+      #
+      #   # bad (always creates a new Array instance)
+      #   [*paths].each { |path| do_something(path) }
+      #
+      #   # good (and a bit more readable)
+      #   Array(paths).each { |path| do_something(path) }
+      #
+      class ArrayCoercion < Base
+        extend AutoCorrector
+
+        SPLAT_MSG = 'Use `Array(%<arg>s)` instead of `[*%<arg>s]`.'
+        CHECK_MSG = 'Use `Array(%<arg>s)` instead of explicit `Array` check.'
+
+        def_node_matcher :array_splat?, <<~PATTERN
+          (array (splat $_))
+        PATTERN
+
+        def_node_matcher :unless_array?, <<~PATTERN
+          (if
+            (send
+              (lvar $_) :is_a?
+              (const nil? :Array)) nil?
+            (lvasgn $_
+              (array
+                (lvar $_))))
+        PATTERN
+
+        def on_array(node)
+          return unless node.square_brackets?
+
+          array_splat?(node) do |arg_node|
+            message = format(SPLAT_MSG, arg: arg_node.source)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, "Array(#{arg_node.source})")
+            end
+          end
+        end
+
+        def on_if(node)
+          unless_array?(node) do |var_a, var_b, var_c|
+            if var_a == var_b && var_c == var_b
+              message = format(CHECK_MSG, arg: var_a)
+              add_offense(node, message: message) do |corrector|
+                corrector.replace(node, "#{var_a} = Array(#{var_a})")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -25,10 +25,11 @@ module RuboCop
 
         def on_send(node)
           TARGET_METHODS.each do |target_class, target_method|
-            target_receiver = s(:const, nil, target_class)
+            next if node.method_name != target_method
 
+            target_receiver = s(:const, nil, target_class)
             next if node.receiver != target_receiver
-            next if node.method_name != target_method
+
             next if cleanup?(node)
 
             add_offense(node,

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

@@ -60,7 +60,7 @@ module RuboCop
         end
 
         def requires_percent_q?(source)
-          style == :percent_q && source =~ /^%[^\w]/
+          style == :percent_q && /^%[^\w]/.match?(source)
         end
 
         def requires_bare_percent?(source)

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where `attr_reader` and `attr_writer`
+      # for the same method can be combined into single `attr_accessor`.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_writer :bar
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_accessor :bar
+      #   end
+      #
+      class BisectedAttrAccessor < Cop
+        include VisibilityHelp
+
+        MSG = 'Combine both accessors into `attr_accessor %<name>s`.'
+
+        def on_class(class_node)
+          VISIBILITY_SCOPES.each do |visibility|
+            reader_names, writer_names = accessor_names(class_node, visibility)
+            next unless reader_names && writer_names
+
+            accessor_macroses(class_node, visibility).each do |macro|
+              check(macro, reader_names, writer_names)
+            end
+          end
+        end
+        alias on_sclass on_class
+        alias on_module on_class
+
+        def autocorrect(node)
+          macro = node.parent
+
+          lambda do |corrector|
+            corrector.replace(macro, replacement(macro, node))
+          end
+        end
+
+        private
+
+        def accessor_names(class_node, visibility)
+          reader_names = nil
+          writer_names = nil
+
+          accessor_macroses(class_node, visibility).each do |macro|
+            names = macro.arguments.map(&:source)
+
+            names.each do |name|
+              if attr_reader?(macro)
+                (reader_names ||= Set.new).add(name)
+              else
+                (writer_names ||= Set.new).add(name)
+              end
+            end
+          end
+
+          [reader_names, writer_names]
+        end
+
+        def accessor_macroses(class_node, visibility)
+          class_def = class_node.body
+          return [] if !class_def || class_def.def_type?
+
+          send_nodes =
+            if class_def.send_type?
+              [class_def]
+            else
+              class_def.each_child_node(:send)
+            end
+
+          send_nodes.select { |node| attr_within_visibility_scope?(node, visibility) }
+        end
+
+        def attr_within_visibility_scope?(node, visibility)
+          node.macro? &&
+            (attr_reader?(node) || attr_writer?(node)) &&
+            node_visibility(node) == visibility
+        end
+
+        def attr_reader?(send_node)
+          send_node.method?(:attr_reader) || send_node.method?(:attr)
+        end
+
+        def attr_writer?(send_node)
+          send_node.method?(:attr_writer)
+        end
+
+        def check(macro, reader_names, writer_names)
+          macro.arguments.each do |arg_node|
+            name = arg_node.source
+
+            if (attr_reader?(macro) && writer_names.include?(name)) ||
+               (attr_writer?(macro) && reader_names.include?(name))
+              add_offense(arg_node, message: format(MSG, name: name))
+            end
+          end
+        end
+
+        def replacement(macro, node)
+          class_node = macro.each_ancestor(:class, :sclass, :module).first
+          reader_names, writer_names = accessor_names(class_node, node_visibility(macro))
+
+          rest_args = rest_args(macro.arguments, reader_names, writer_names)
+
+          if attr_reader?(macro)
+            attr_reader_replacement(macro, node, rest_args)
+          elsif rest_args.empty?
+            ''
+          else
+            "#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
+          end
+        end
+
+        def rest_args(args, reader_names, writer_names)
+          args.reject do |arg|
+            name = arg.source
+            reader_names.include?(name) && writer_names.include?(name)
+          end
+        end
+
+        def attr_reader_replacement(macro, node, rest_args)
+          if rest_args.empty?
+            "attr_accessor #{node.source}"
+          else
+            "attr_accessor #{node.source}\n"\
+            "#{indent(macro)}#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
+          end
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
+      end
+    end
+  end
+end