rubocop 0.49.1 → 0.52.0

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

@@ -45,7 +45,7 @@ module RuboCop
           return unless outer_local_variable
 
           message = format(MSG, variable.name)
-          add_offense(variable.declaration_node, :expression, message)
+          add_offense(variable.declaration_node, message: message)
         end
       end
     end

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

@@ -29,16 +29,10 @@ module RuboCop
             next unless final_node && final_node.send_type? &&
                         final_node.method?(:to_s) && !final_node.arguments?
 
-            add_offense(final_node, :selector)
+            add_offense(final_node, location: :selector)
           end
         end
 
-        private
-
-        def message(node)
-          node.receiver ? MSG_DEFAULT : MSG_SELF
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             receiver, _method_name, *_args = *node
@@ -52,6 +46,12 @@ module RuboCop
             )
           end
         end
+
+        private
+
+        def message(node)
+          node.receiver ? MSG_DEFAULT : MSG_SELF
+        end
       end
     end
   end

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

@@ -5,50 +5,53 @@ module RuboCop
     module Lint
       # This is actually not a cop and inspects nothing. It just provides
       # methods to repack Parser's diagnostics/errors into RuboCop's offenses.
-      module Syntax
+      class Syntax < Cop
         PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
                                        :end_pos)
 
-        COP_NAME = 'Syntax'.freeze
         ERROR_SOURCE_RANGE = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
 
-        def self.offenses_from_processed_source(processed_source)
-          offenses = []
+        def self.offenses_from_processed_source(processed_source,
+                                                config, options)
+          cop = new(config, options)
 
           if processed_source.parser_error
-            offenses << offense_from_error(processed_source.parser_error)
+            cop.add_offense_from_error(processed_source.parser_error)
           end
 
           processed_source.diagnostics.each do |diagnostic|
-            offenses << offense_from_diagnostic(diagnostic,
-                                                processed_source.ruby_version)
+            cop.add_offense_from_diagnostic(diagnostic,
+                                            processed_source.ruby_version)
           end
 
-          offenses
+          cop.offenses
         end
 
-        def self.offense_from_diagnostic(diagnostic, ruby_version)
-          Offense.new(
-            diagnostic.level,
-            diagnostic.location,
+        def add_offense_from_diagnostic(diagnostic, ruby_version)
+          message =
             "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
-            'configure using `TargetRubyVersion` parameter, under `AllCops`)',
-            COP_NAME
-          )
+            'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+          add_offense(nil,
+                      location: diagnostic.location,
+                      message: message,
+                      severity: diagnostic.level)
         end
 
-        def self.offense_from_error(error)
+        def add_offense_from_error(error)
           message = beautify_message(error.message)
-          Offense.new(:fatal, ERROR_SOURCE_RANGE, message, COP_NAME)
+          add_offense(nil,
+                      location: ERROR_SOURCE_RANGE,
+                      message: message,
+                      severity: :fatal)
         end
 
-        def self.beautify_message(message)
+        private
+
+        def beautify_message(message)
           message = message.capitalize
           message << '.' unless message.end_with?('.')
           message
         end
-
-        private_class_method :beautify_message
       end
     end
   end

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

@@ -54,7 +54,7 @@ module RuboCop
                        node.loc.name
                      end
 
-          add_offense(nil, location)
+          add_offense(nil, location: location)
         end
       end
     end

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

@@ -20,15 +20,16 @@ module RuboCop
       class UnifiedInteger < Cop
         MSG = 'Use `Integer` instead of `%s`.'.freeze
 
-        def_node_matcher :fixnum_or_bignum_const?, <<-PATTERN
-          (:const {nil (:cbase)} ${:Fixnum :Bignum})
+        def_node_matcher :fixnum_or_bignum_const, <<-PATTERN
+          (:const {nil? (:cbase)} ${:Fixnum :Bignum})
         PATTERN
 
         def on_const(node)
-          klass = fixnum_or_bignum_const?(node)
+          klass = fixnum_or_bignum_const(node)
+
           return unless klass
 
-          add_offense(node, :expression, format(MSG, klass))
+          add_offense(node, message: format(MSG, klass))
         end
 
         def autocorrect(node)

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

@@ -1,5 +1,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
@@ -12,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
 
@@ -48,12 +61,15 @@ module RuboCop
           # 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_with_surrounding_space(range, :right,
+          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.
-                                       original_begin.zero?)
+                                       newlines: original_begin.zero?)
         end
 
         def directive_range_in_list(range, ranges)
@@ -61,13 +77,15 @@ module RuboCop
           # 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_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, :right, false)
+          range_with_surrounding_space(range: range,
+                                       side: :right,
+                                       newlines: false)
         end
 
         def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments,
@@ -75,7 +93,8 @@ module RuboCop
           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
 
@@ -88,10 +107,7 @@ module RuboCop
                             cop)
           line_ranges.each_with_index do |line_range, ix|
             comment = comments.find { |c| c.loc.line == line_range.begin }
-
-            unless all_disabled?(comment)
-              next if ignore_offense?(disabled_ranges, line_range)
-            end
+            next if ignore_offense?(disabled_ranges, line_range)
 
             unneeded_cop = find_unneeded(comment, offenses, cop, line_range,
                                          line_ranges[ix + 1])
@@ -99,8 +115,9 @@ module RuboCop
           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
@@ -137,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)
@@ -166,8 +183,12 @@ module RuboCop
         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,
-                      "Unnecessary disabling of #{cop_list.join(', ')}.")
+
+          add_offense(
+            [[location], location],
+            location: location,
+            message: "Unnecessary disabling of #{cop_list.join(', ')}."
+          )
         end
 
         def add_offense_for_some_cops(comment, cops)
@@ -176,8 +197,11 @@ module RuboCop
           ranges = cop_ranges.map { |_, r| r }
 
           cop_ranges.each do |cop, range|
-            add_offense([ranges, range], range,
-                        "Unnecessary disabling of #{describe(cop)}.")
+            add_offense(
+              [ranges, range],
+              location: range,
+              message: "Unnecessary disabling of #{describe(cop)}."
+            )
           end
         end
 
@@ -229,3 +253,4 @@ module RuboCop
     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

@@ -56,42 +56,68 @@ module RuboCop
         PERCENT_CAPITAL_W = '%W'.freeze
         PERCENT_I = '%i'.freeze
         PERCENT_CAPITAL_I = '%I'.freeze
-        ARRAY_NEW_PATTERN = '$(send (const nil :Array) :new ...)'.freeze
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
-        def_node_matcher :literal_expansion?, <<-PATTERN
-          (splat {$({str dstr int float array} ...) (block #{ARRAY_NEW_PATTERN} ...) #{ARRAY_NEW_PATTERN}} ...)
+        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)
-          literal_expansion?(node) do |object|
-            if object.send_type?
-              return unless ASSIGNMENT_TYPES.include?(node.parent.parent.type)
-            end
-
+          unneeded_splat_expansion(node) do
             if array_splat?(node) &&
                (method_argument?(node) || part_of_an_array?(node))
-              add_offense(node, :expression, ARRAY_PARAM_MSG)
+              add_offense(node, message: ARRAY_PARAM_MSG)
             else
-              add_offense(node, :expression)
+              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 autocorrect(node)
+        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
 
-          lambda do |corrector|
-            if !variable.array_type?
-              corrector.replace(loc.expression, "[#{variable.source}]")
-            elsif unneeded_brackets?(node)
-              corrector.replace(loc.expression, remove_brackets(variable))
-            else
-              corrector.remove(loc.operator)
-            end
+          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
 

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

@@ -16,6 +16,17 @@ module RuboCop
       #     do_something
       #   end
       #
+      #   # bad
+      #
+      #   def some_method
+      #     if cond
+      #       return
+      #     else
+      #       return
+      #     end
+      #     do_something
+      #   end
+      #
       # @example
       #
       #   # good
@@ -26,25 +37,59 @@ module RuboCop
       class UnreachableCode < Cop
         MSG = 'Unreachable code detected.'.freeze
 
-        NODE_TYPES = %i[return next break retry redo].freeze
-        FLOW_COMMANDS = %i[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)
+            next unless flow_expression?(e1)
 
-            add_offense(e2, :expression)
+            add_offense(e2)
           end
         end
 
+        alias on_kwbegin on_begin
+
         private
 
-        def flow_command?(node)
-          return false unless node.send_type?
+        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
 
-          FLOW_COMMANDS.any? { |c| node.command?(c) }
+        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