rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/lint/unneeded_disable.rb

@@ -1,6 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
+# The Lint/UnneededDisable cop needs to be disabled so as to be able to provide
+# a (bad) example of an unneeded disable.
+# rubocop:disable Lint/UnneededDisable
 module RuboCop
   module Cop
     module Lint
@@ -13,6 +15,16 @@ module RuboCop
       # their work. Instead, it waits until it's called in a later stage of the
       # execution. The reason it can't be implemented as a normal cop is that
       # it depends on the results of all other cops to do its work.
+      #
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Metrics/LineLength
+      #   x += 1
+      #   # rubocop:enable Metrics/LineLength
+      #
+      #   # good
+      #   x += 1
       class UnneededDisable < Cop
         include NameSimilarity
 
@@ -33,30 +45,11 @@ module RuboCop
           lambda do |corrector|
             ranges, range = *args # Ranges are sorted by position.
 
-            if range.source.start_with?('#')
-              # Eat the entire comment, the preceding space, and the preceding
-              # newline if there is one.
-              original_begin = range.begin_pos
-              range = range_with_surrounding_space(range, :left, true)
-              range = range_with_surrounding_space(range, :right,
-                                                   # Special for a comment that
-                                                   # begins the file: remove
-                                                   # the newline at the end.
-                                                   original_begin.zero?)
-            else
-              # Is there any cop between this one and the end of the line, which
-              # is NOT being removed?
-
-              if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
-                # Eat the comma on the left.
-                range = range_with_surrounding_space(range, :left)
-                range = range_with_surrounding_comma(range, :left)
-              end
-
-              range = range_with_surrounding_comma(range, :right)
-              # Eat following spaces up to EOL, but not the newline itself.
-              range = range_with_surrounding_space(range, :right, false)
-            end
+            range = if range.source.start_with?('#')
+                      comment_range_with_surrounding_space(range)
+                    else
+                      directive_range_in_list(range, ranges)
+                    end
 
             corrector.remove(range)
           end
@@ -64,42 +57,96 @@ module RuboCop
 
         private
 
-        def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments)
+        def comment_range_with_surrounding_space(range)
+          # Eat the entire comment, the preceding space, and the preceding
+          # newline if there is one.
+          original_begin = range.begin_pos
+          range = range_with_surrounding_space(range: range,
+                                               side: :left,
+                                               newlines: true)
+          range_with_surrounding_space(range: range,
+                                       side: :right,
+                                       # Special for a comment that
+                                       # begins the file: remove
+                                       # the newline at the end.
+                                       newlines: original_begin.zero?)
+        end
+
+        def directive_range_in_list(range, ranges)
+          # Is there any cop between this one and the end of the line, which
+          # is NOT being removed?
+          if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
+            # Eat the comma on the left.
+            range = range_with_surrounding_space(range: range, side: :left)
+            range = range_with_surrounding_comma(range, :left)
+          end
+
+          range = range_with_surrounding_comma(range, :right)
+          # Eat following spaces up to EOL, but not the newline itself.
+          range_with_surrounding_space(range: range,
+                                       side: :right,
+                                       newlines: false)
+        end
+
+        def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments,
+                                  &block)
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
-            each_already_disabled(line_ranges, comments) do |comment|
+            each_already_disabled(line_ranges,
+                                  disabled_ranges, comments) do |comment|
               yield comment, cop
             end
 
-            line_ranges.each do |line_range|
-              comment = comments.find { |c| c.loc.line == line_range.begin }
+            each_line_range(line_ranges, disabled_ranges, offenses, comments,
+                            cop, &block)
+          end
+        end
 
-              unless all_disabled?(comment)
-                next if ignore_offense?(disabled_ranges, line_range)
-              end
+        def each_line_range(line_ranges, disabled_ranges, offenses, comments,
+                            cop)
+          line_ranges.each_with_index do |line_range, ix|
+            comment = comments.find { |c| c.loc.line == line_range.begin }
+            next if ignore_offense?(disabled_ranges, line_range)
 
-              unneeded_cop = find_unneeded(comment, offenses, cop, line_range)
-              yield comment, unneeded_cop if unneeded_cop
-            end
+            unneeded_cop = find_unneeded(comment, offenses, cop, line_range,
+                                         line_ranges[ix + 1])
+            yield comment, unneeded_cop if unneeded_cop
           end
         end
 
-        def each_already_disabled(line_ranges, comments)
+        def each_already_disabled(line_ranges, disabled_ranges, comments)
           line_ranges.each_cons(2) do |previous_range, range|
+            next if ignore_offense?(disabled_ranges, range)
             next if previous_range.end != range.begin
 
             # If a cop is disabled in a range that begins on the same line as
             # the end of the previous range, it means that the cop was
             # already disabled by an earlier comment. So it's unneeded
             # whether there are offenses or not.
-            yield comments.find { |c| c.loc.line == range.begin }
+            unneeded_comment = comments.find do |c|
+              c.loc.line == range.begin &&
+                # Comments disabling all cops don't count since it's reasonable
+                # to disable a few select cops first and then all cops further
+                # down in the code.
+                !all_disabled?(c)
+            end
+            yield unneeded_comment if unneeded_comment
           end
         end
 
-        def find_unneeded(comment, offenses, cop, line_range)
+        def find_unneeded(comment, offenses, cop, line_range, next_line_range)
           if all_disabled?(comment)
-            'all' if offenses.none? { |o| line_range.cover?(o.line) }
+            # If there's a disable all comment followed by a comment
+            # specifically disabling `cop`, we don't report the `all`
+            # comment. If the disable all comment is truly unneeded, we will
+            # detect that when examining the comments of another cop, and we
+            # get the full line range for the disable all.
+            if (next_line_range.nil? ||
+                line_range.last != next_line_range.first) &&
+               offenses.none? { |o| line_range.cover?(o.line) }
+              'all'
+            end
           else
             cop_offenses = offenses.select { |o| o.cop_name == cop }
             cop if cop_offenses.none? { |o| line_range.cover?(o.line) }
@@ -107,7 +154,7 @@ module RuboCop
         end
 
         def all_disabled?(comment)
-          comment.text =~ /rubocop:disable\s+all\b/
+          comment.text =~ /rubocop\s*:\s*disable\s+all\b/
         end
 
         def ignore_offense?(disabled_ranges, line_range)
@@ -124,30 +171,43 @@ module RuboCop
 
         def add_offenses(unneeded_cops)
           unneeded_cops.each do |comment, cops|
-            # Is the entire rubocop:disable line useless, or should just
-            # some of the mentioned cops be removed?
             if all_disabled?(comment) ||
                directive_count(comment) == cops.size
-              location = comment.loc.expression
-              cop_list = cops.sort.map { |c| describe(c) }
-              add_offense([[location], location], location,
-                          "Unnecessary disabling of #{cop_list.join(', ')}.")
+              add_offense_for_entire_comment(comment, cops)
             else
-              cop_ranges = cops.map { |c| [c, cop_range(comment, c)] }
-              cop_ranges.sort_by! { |_, r| r.begin_pos }
-              ranges = cop_ranges.map { |_, r| r }
-
-              cop_ranges.each do |cop, range|
-                add_offense([ranges, range], range,
-                            "Unnecessary disabling of #{describe(cop)}.")
-              end
+              add_offense_for_some_cops(comment, cops)
             end
           end
         end
 
+        def add_offense_for_entire_comment(comment, cops)
+          location = comment.loc.expression
+          cop_list = cops.sort.map { |c| describe(c) }
+
+          add_offense(
+            [[location], location],
+            location: location,
+            message: "Unnecessary disabling of #{cop_list.join(', ')}."
+          )
+        end
+
+        def add_offense_for_some_cops(comment, cops)
+          cop_ranges = cops.map { |c| [c, cop_range(comment, c)] }
+          cop_ranges.sort_by! { |_, r| r.begin_pos }
+          ranges = cop_ranges.map { |_, r| r }
+
+          cop_ranges.each do |cop, range|
+            add_offense(
+              [ranges, range],
+              location: range,
+              message: "Unnecessary disabling of #{describe(cop)}."
+            )
+          end
+        end
+
         def cop_range(comment, cop)
           matching_range(comment.loc.expression, cop) ||
-            matching_range(comment.loc.expression, cop.split('/').last) ||
+            matching_range(comment.loc.expression, Badge.parse(cop).cop_name) ||
             raise("Couldn't find #{cop} in comment: #{comment.text}")
         end
 
@@ -187,9 +247,10 @@ module RuboCop
         end
 
         def all_cop_names
-          @all_cop_names ||= Cop.all.map(&:cop_name)
+          @all_cop_names ||= Cop.registry.names
         end
       end
     end
   end
 end
+# rubocop:enable Lint/UnneededDisable

data/lib/rubocop/cop/lint/unneeded_require_statement.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for unnecessary `require` statement.
+      #
+      # The following features are unnecessary `require` statement because
+      # they are already loaded.
+      #
+      # ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
+      # ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
+      # ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
+      #
+      # This cop targets Ruby 2.2 or higher containing these 4 features.
+      #
+      # @example
+      #   # bad
+      #   require 'unloaded_feature'
+      #   require 'thread'
+      #
+      #   # good
+      #   require 'unloaded_feature'
+      class UnneededRequireStatement < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.2
+
+        MSG = 'Remove unnecessary `require` statement.'.freeze
+
+        def_node_matcher :unnecessary_require_statement?, <<-PATTERN
+          (send nil? :require
+            (str {"enumerator" "rational" "complex" "thread"}))
+        PATTERN
+
+        def on_send(node)
+          return unless unnecessary_require_statement?(node)
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_with_surrounding_space(range: node.loc.expression,
+                                                 side: :right)
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/unneeded_splat_expansion.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unneeded usages of splat expansion
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   a = *[1, 2, 3]
+      #   a = *'a'
+      #   a = *1
+      #
+      #   begin
+      #     foo
+      #   rescue *[StandardError, ApplicationError]
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   c = [1, 2, 3]
+      #   a = *c
+      #   a, b = *c
+      #   a, *b = *c
+      #   a = *1..10
+      #   a = ['a']
+      #
+      #   begin
+      #     foo
+      #   rescue StandardError, ApplicationError
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      class UnneededSplatExpansion < Cop
+        MSG = 'Unnecessary splat expansion.'.freeze
+        ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'.freeze
+        PERCENT_W = '%w'.freeze
+        PERCENT_CAPITAL_W = '%W'.freeze
+        PERCENT_I = '%i'.freeze
+        PERCENT_CAPITAL_I = '%I'.freeze
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
+
+        def_node_matcher :array_new?, '$(send (const nil? :Array) :new ...)'
+
+        def_node_matcher :literal_expansion, <<-PATTERN
+          (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
+        PATTERN
+
+        def on_splat(node)
+          unneeded_splat_expansion(node) do
+            if array_splat?(node) &&
+               (method_argument?(node) || part_of_an_array?(node))
+              add_offense(node, message: ARRAY_PARAM_MSG)
+            else
+              add_offense(node)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          range, content = replacement_range_and_content(node)
+
+          lambda do |corrector|
+            corrector.replace(range, content)
+          end
+        end
+
+        private
+
+        def unneeded_splat_expansion(node)
+          literal_expansion(node) do |expanded_item|
+            if expanded_item.send_type?
+              return if array_new_inside_array_literal?(expanded_item)
+
+              grandparent = node.parent.parent
+              return if grandparent &&
+                        !ASSIGNMENT_TYPES.include?(grandparent.type)
+            end
+
+            yield
+          end
+        end
+
+        def array_new_inside_array_literal?(array_new_node)
+          return false unless array_new?(array_new_node)
+
+          grandparent = array_new_node.parent.parent
+          grandparent.array_type? && grandparent.children.size > 1
+        end
+
+        def replacement_range_and_content(node)
+          variable, = *node
+          loc = node.loc
+
+          if array_new?(variable)
+            [node.parent.loc.expression, variable.source]
+          elsif !variable.array_type?
+            [loc.expression, "[#{variable.source}]"]
+          elsif unneeded_brackets?(node)
+            [loc.expression, remove_brackets(variable)]
+          else
+            [loc.operator, '']
+          end
+        end
+
+        def array_splat?(node)
+          node.children.first.array_type?
+        end
+
+        def method_argument?(node)
+          node.parent.send_type?
+        end
+
+        def part_of_an_array?(node)
+          # The parent of a splat expansion is an array that does not have
+          # `begin` or `end`
+          parent = node.parent
+          parent.array_type? && parent.loc.begin && parent.loc.end
+        end
+
+        def unneeded_brackets?(node)
+          parent = node.parent
+          grandparent = node.parent.parent
+
+          parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
+            (grandparent && grandparent.resbody_type?)
+        end
+
+        def remove_brackets(array)
+          array_start = array.loc.begin.source
+          elements = *array
+          elements = elements.map(&:source)
+
+          if array_start.start_with?(PERCENT_W)
+            "'#{elements.join("', '")}'"
+          elsif array_start.start_with?(PERCENT_CAPITAL_W)
+            %("#{elements.join('", "')}")
+          elsif array_start.start_with?(PERCENT_I)
+            ":#{elements.join(', :')}"
+          elsif array_start.start_with?(PERCENT_CAPITAL_I)
+            %(:"#{elements.join('", :"')}")
+          else
+            elements.join(', ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/unreachable_code.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,25 +6,90 @@ module RuboCop
       # This cop checks for unreachable code.
       # The check are based on the presence of flow of control
       # statement in non-final position in *begin*(implicit) blocks.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     return
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     if cond
+      #       return
+      #     else
+      #       return
+      #     end
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   end
       class UnreachableCode < Cop
         MSG = 'Unreachable code detected.'.freeze
 
-        NODE_TYPES = [:return, :next, :break, :retry, :redo].freeze
-        FLOW_COMMANDS = [:throw, :raise, :fail].freeze
-
         def on_begin(node)
           expressions = *node
 
           expressions.each_cons(2) do |e1, e2|
-            next unless NODE_TYPES.include?(e1.type) || flow_command?(e1)
-            add_offense(e2, :expression)
+            next unless flow_expression?(e1)
+
+            add_offense(e2)
           end
         end
 
+        alias on_kwbegin on_begin
+
         private
 
-        def flow_command?(node)
-          FLOW_COMMANDS.any? { |c| node.command?(c) }
+        def_node_matcher :flow_command?, <<-PATTERN
+          {
+            return next break retry redo
+            (send
+             {nil? (const {nil? cbase} :Kernel)}
+             {:raise :fail :throw}
+             ...)
+          }
+        PATTERN
+
+        def flow_expression?(node)
+          return true if flow_command?(node)
+          case node.type
+          when :begin, :kwbegin
+            expressions = *node
+            expressions.any? { |expr| flow_expression?(expr) }
+          when :if
+            check_if(node)
+          when :case
+            check_case(node)
+          else
+            false
+          end
+        end
+
+        def check_if(node)
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          if_branch && else_branch &&
+            flow_expression?(if_branch) && flow_expression?(else_branch)
+        end
+
+        def check_case(node)
+          else_branch = node.else_branch
+          return false unless else_branch
+          return false unless flow_expression?(else_branch)
+          node.when_branches.all? do |branch|
+            branch.body && flow_expression?(branch.body)
+          end
         end
       end
     end