rubocop 0.50.0 → 0.51.0

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

@@ -21,7 +21,7 @@ module RuboCop
         MSG = 'Use `Integer` instead of `%s`.'.freeze
 
         def_node_matcher :fixnum_or_bignum_const, <<-PATTERN
-          (:const {nil (:cbase)} ${:Fixnum :Bignum})
+          (:const {nil? (:cbase)} ${:Fixnum :Bignum})
         PATTERN
 
         def on_const(node)
@@ -29,7 +29,7 @@ module RuboCop
 
           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

@@ -166,8 +166,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 +180,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
 

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

@@ -0,0 +1,50 @@
+# 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(node.loc.expression, :right)
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -56,7 +56,7 @@ 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
+        ARRAY_NEW_PATTERN = '$(send (const nil? :Array) :new ...)'.freeze
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
         def_node_matcher :literal_expansion?, <<-PATTERN
@@ -71,7 +71,7 @@ module RuboCop
 
             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)
             end

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

@@ -55,7 +55,7 @@ module RuboCop
           {
             return next break retry redo
             (send
-             {nil (const {nil cbase} :Kernel)}
+             {nil? (const {nil? cbase} :Kernel)}
              {:raise :fail :throw}
              ...)
           }

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

@@ -29,7 +29,8 @@ module RuboCop
                     cop_config['AllowUnusedKeywordArguments']
 
           if cop_config['IgnoreEmptyMethods']
-            _name, _args, body = *variable.scope.node
+            body = variable.scope.node.body
+
             return if body.nil?
           end
 

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

@@ -45,7 +45,7 @@ module RuboCop
 
         def_node_matcher :uri_escape_unescape?, <<-PATTERN
           (send
-            (const ${nil cbase} :URI) ${:escape :encode :unescape :decode}
+            (const ${nil? cbase} :URI) ${:escape :encode :unescape :decode}
             ...)
         PATTERN
 
@@ -65,7 +65,7 @@ module RuboCop
               *replacement_methods
             )
 
-            add_offense(node, :expression, message)
+            add_offense(node, message: message)
           end
         end
       end

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

@@ -20,13 +20,13 @@ module RuboCop
 
         def_node_matcher :uri_regexp_with_argument?, <<-PATTERN
           (send
-            (const ${nil cbase} :URI) :regexp
+            (const ${nil? cbase} :URI) :regexp
             (str $_))
         PATTERN
 
         def_node_matcher :uri_regexp_without_argument?, <<-PATTERN
           (send
-            (const ${nil cbase} :URI) :regexp)
+            (const ${nil? cbase} :URI) :regexp)
         PATTERN
 
         def on_send(node)
@@ -65,7 +65,7 @@ module RuboCop
         def register_offense(node, top_level: '', arg: '')
           format = format(MSG, top_level: top_level, arg: arg)
 
-          add_offense(node, :selector, format)
+          add_offense(node, location: :selector, message: format)
         end
       end
     end

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

@@ -114,11 +114,11 @@ module RuboCop
         private
 
         def_node_matcher :static_method_definition?, <<-PATTERN
-          {def (send nil {:attr :attr_reader :attr_writer :attr_accessor} ...)}
+          {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
         PATTERN
 
         def_node_matcher :dynamic_method_definition?, <<-PATTERN
-          {(send nil :define_method ...) (block (send nil :define_method ...) ...)}
+          {(send nil? :define_method ...) (block (send nil? :define_method ...) ...)}
         PATTERN
 
         def_node_matcher :class_or_instance_eval?, <<-PATTERN
@@ -126,7 +126,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
-          (block (send (const nil {:Class :Module :Struct}) :new ...) ...)
+          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
         def check_node(node)
@@ -135,14 +135,14 @@ module RuboCop
           if node.begin_type?
             check_scope(node)
           elsif node.send_type? && node.access_modifier?
-            add_offense(node, :expression, format(MSG, node.method_name))
+            add_offense(node, message: format(MSG, node.method_name))
           end
         end
 
         def check_scope(node)
           cur_vis, unused = check_child_nodes(node, nil, :public)
 
-          add_offense(unused, :expression, format(MSG, cur_vis)) if unused
+          add_offense(unused, message: format(MSG, cur_vis)) if unused
         end
 
         def check_child_nodes(node, unused, cur_vis)
@@ -165,10 +165,10 @@ module RuboCop
         def check_new_visibility(node, unused, new_vis, cur_vis)
           # does this modifier just repeat the existing visibility?
           if new_vis == cur_vis
-            add_offense(node, :expression, format(MSG, cur_vis))
+            add_offense(node, message: format(MSG, cur_vis))
           else
             # was the previous modifier never applied to any defs?
-            add_offense(unused, :expression, format(MSG, cur_vis)) if unused
+            add_offense(unused, message: format(MSG, cur_vis)) if unused
             # once we have already warned about a certain modifier, don't
             # warn again even if it is never applied to any method defs
             unused = node
@@ -188,7 +188,7 @@ module RuboCop
             matcher_name = "#{m}_method?".to_sym
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<-PATTERN
-                {def (send nil :#{m} ...)}
+                {def (send nil? :#{m} ...)}
               PATTERN
             end
 
@@ -212,7 +212,7 @@ module RuboCop
             matcher_name = "#{m}_block?".to_sym
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<-PATTERN
-                (block (send {nil const} {:#{m}} ...) ...)
+                (block (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 

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

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

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

@@ -20,7 +20,7 @@ module RuboCop
         def on_send(node)
           return unless useless_comparison?(node)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -39,7 +39,11 @@ module RuboCop
           variable_name, = *receiver
           return unless tracker.contain_local_object?(variable_name)
 
-          add_offense(receiver, :name, format(MSG, receiver.loc.name.source))
+          add_offense(
+            receiver,
+            location: :name,
+            message: format(MSG, receiver.loc.name.source)
+          )
         end
         alias on_defs on_def
 

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

@@ -75,30 +75,35 @@ module RuboCop
         def check_void_op(node)
           return unless node.send_type? && OPERATORS.include?(node.method_name)
 
-          add_offense(node, :selector, format(OP_MSG, node.method_name))
+          add_offense(node,
+                      location: :selector,
+                      message: format(OP_MSG, node.method_name))
         end
 
         def check_var(node)
           return unless node.variable? || node.const_type?
-          add_offense(node, :name, format(VAR_MSG, node.loc.name.source))
+
+          add_offense(node,
+                      location: :name,
+                      message: format(VAR_MSG, node.loc.name.source))
         end
 
         def check_literal(node)
           return if !node.literal? || node.xstr_type?
 
-          add_offense(node, :expression, format(LIT_MSG, node.source))
+          add_offense(node, message: format(LIT_MSG, node.source))
         end
 
         def check_self(node)
           return unless node.self_type?
 
-          add_offense(node, :expression, SELF_MSG)
+          add_offense(node, message: SELF_MSG)
         end
 
         def check_defined(node)
           return unless node.defined_type?
 
-          add_offense(node, :expression, format(DEFINED_MSG, node.source))
+          add_offense(node, message: format(DEFINED_MSG, node.source))
         end
 
         def in_void_context?(node)

data/lib/rubocop/cop/metrics/block_nesting.rb

@@ -33,7 +33,7 @@ module RuboCop
             if current_level > max
               self.max = current_level
               unless part_of_ignored_node?(node)
-                add_offense(node, :expression, message(max)) do
+                add_offense(node, message: message(max)) do
                   ignore_node(node)
                 end
               end

data/lib/rubocop/cop/metrics/line_length.rb

@@ -44,7 +44,10 @@ module RuboCop
 
         def register_offense(loc, line)
           message = format(MSG, line.length, max)
-          add_offense(nil, loc, message) { self.max = line.length }
+
+          add_offense(nil, location: loc, message: message) do
+            self.max = line.length
+          end
         end
 
         def excess_range(uri_range, line, index)

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -5,8 +5,7 @@ module RuboCop
     module Metrics
       # This cop checks for methods with too many parameters.
       # The maximum number of parameters is configurable.
-      # On Ruby 2.0+ keyword arguments can optionally
-      # be excluded from the total count.
+      # Keyword arguments can optionally be excluded from the total count.
       class ParameterLists < Cop
         include ConfigurableMax
 

data/lib/rubocop/cop/mixin/array_hash_indentation.rb

@@ -72,8 +72,9 @@ module RuboCop
       end
 
       def incorrect_style_detected(styles, first, left_parenthesis)
-        add_offense(first, :expression,
-                    message(base_description(left_parenthesis))) do
+        msg = message(base_description(left_parenthesis))
+
+        add_offense(first, message: msg) do
           ambiguous_style_detected(*styles)
         end
       end

data/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -39,7 +39,7 @@ module RuboCop
             # autocorrecting it. Two rewrites in the same area by the same
             # cop can not be handled. The next iteration will find the
             # offense again and correct it.
-            add_offense(nil, expr)
+            add_offense(nil, location: expr)
           else
             add_offense(current)
           end

data/lib/rubocop/cop/mixin/code_length.rb

@@ -18,7 +18,7 @@ module RuboCop
         length = code_length(node)
         return unless length > max_length
 
-        add_offense(node, :expression, message(length, max_length)) do
+        add_offense(node, message: message(length, max_length)) do
           self.max = length
         end
       end

data/lib/rubocop/cop/mixin/configurable_formatting.rb

@@ -12,7 +12,7 @@ module RuboCop
         if valid_name?(node, name)
           correct_style_detected
         else
-          add_offense(node, name_range, message(style)) do
+          add_offense(node, location: name_range, message: message(style)) do
             report_opposing_styles(node, name)
           end
         end

data/lib/rubocop/cop/mixin/def_node.rb

@@ -20,7 +20,7 @@ module RuboCop
       end
 
       def_node_matcher :non_public_modifier?, <<-PATTERN
-        (send nil {:private :protected} ({def defs} ...))
+        (send nil? {:private :protected} ({def defs} ...))
       PATTERN
     end
   end

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -102,7 +102,7 @@ module RuboCop
 
           offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
           range = source_range(processed_source.buffer, line + offset, 0)
-          add_offense([style, range], range, msg)
+          add_offense([style, range], location: range, message: msg)
         end
 
         def check_deferred_empty_line(body)
@@ -113,7 +113,12 @@ module RuboCop
           return if processed_source[line].empty?
 
           range = source_range(processed_source.buffer, line + 2, 0)
-          add_offense([:empty_lines, range], range, deferred_message(node))
+
+          add_offense(
+            [:empty_lines, range],
+            location: range,
+            message: deferred_message(node)
+          )
         end
 
         def namespace?(body, with_one_child: false)

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -41,7 +41,7 @@ module RuboCop
         end_loc = node.loc.end
         msg = format(MSG, end_loc.line, end_loc.column, align_with.source,
                      align_with.line, align_with.column)
-        add_offense(node, end_loc, msg)
+        add_offense(node, location: end_loc, message: msg)
       end
 
       def style_parameter_name

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -10,7 +10,7 @@ module RuboCop
         PATTERN
 
         base.def_node_matcher :class_new_definition, <<-PATTERN
-        [!^(casgn nil :#{base::SUPERCLASS} ...) (send (const nil :Class) :new #{base::BASE_PATTERN})]
+        [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
         PATTERN
       end