rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,7 +9,9 @@ module RuboCop
       # used for that.
       #
       # @example
-      #   @bad
+      #
+      #   # bad
+      #
       #   class C
       #     private
       #
@@ -19,7 +20,10 @@ module RuboCop
       #     end
       #   end
       #
-      #   @good
+      # @example
+      #
+      #   # good
+      #
       #   class C
       #     def self.method
       #       puts 'hi'
@@ -28,6 +32,10 @@ module RuboCop
       #     private_class_method :method
       #   end
       #
+      # @example
+      #
+      #   # good
+      #
       #   class C
       #     class << self
       #       private
@@ -45,12 +53,8 @@ module RuboCop
         ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
                                 'block'.freeze
 
-        def_node_matcher :access_modifier, <<-PATTERN
-          (send nil ${:public :protected :private})
-        PATTERN
-
         def_node_matcher :private_class_method, <<-PATTERN
-          (send nil :private_class_method $...)
+          (send nil? :private_class_method $...)
         PATTERN
 
         def on_class(node)
@@ -69,14 +73,15 @@ module RuboCop
         end
 
         def check_node(node)
-          if node && node.begin_type?
-            clear
-            check_scope(node)
-
-            @useless.each do |_name, (defs_node, visibility, modifier)|
-              add_offense(defs_node, :keyword,
-                          format_message(visibility, modifier))
-            end
+          return unless node && node.begin_type?
+
+          clear
+          check_scope(node)
+
+          @useless.each do |_name, (defs_node, visibility, modifier)|
+            add_offense(defs_node,
+                        location: :keyword,
+                        message: format_message(visibility, modifier))
           end
         end
 
@@ -91,42 +96,50 @@ module RuboCop
         end
 
         def check_scope(node, cur_vis = :public)
-          node.children.reduce(cur_vis) do |visibility, child|
+          node.each_child_node.reduce(cur_vis) do |visibility, child|
             check_child_scope(child, visibility)
           end
         end
 
         def check_child_scope(node, cur_vis)
-          if (new_vis = access_modifier(node))
-            cur_vis = change_visibility(node, new_vis)
-          elsif node.defs_type?
-            mark_method_as_useless(node, cur_vis) if cur_vis != :public
+          case node.type
+          when :send
+            cur_vis = check_send(node, cur_vis)
+          when :defs
+            check_defs(node, cur_vis)
+          when :kwbegin
+            check_scope(node, cur_vis)
+          end
+
+          cur_vis
+        end
+
+        def check_send(node, cur_vis)
+          if node.access_modifier? && !node.method?(:module_function)
+            @last_access_modifier = node
+            return node.method_name
           elsif (methods = private_class_method(node))
             # don't warn about defs nodes which are followed by a call to
             # `private_class_method :name`
             # obviously the programmer knows what they are doing
             revert_method_uselessness(methods)
-          elsif node.kwbegin_type?
-            cur_vis = check_scope(node, cur_vis)
           end
 
           cur_vis
         end
 
-        def change_visibility(node, new_vis)
-          @last_access_modifier = node
-          new_vis
+        def check_defs(node, cur_vis)
+          mark_method_as_useless(node, cur_vis) if cur_vis != :public
         end
 
         def mark_method_as_useless(node, cur_vis)
-          _, method_name, = *node
-          @useless[method_name] = [node, cur_vis, @last_access_modifier]
+          @useless[node.method_name] = [node, cur_vis, @last_access_modifier]
         end
 
         def revert_method_uselessness(methods)
           methods.each do |sym|
             next unless sym.sym_type?
-            @useless.delete(sym.children[0])
+            @useless.delete(sym.value)
           end
         end
       end

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

@@ -1,30 +1,26 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
-      # This cop looks for error classes inheriting from `Exception`.
-      # It is configurable to suggest using either `RuntimeError` (default) or
-      # `StandardError` instead.
-      #
-      # @example
+      # This cop looks for error classes inheriting from `Exception`
+      # and its standard library subclasses, excluding subclasses of
+      # `StandardError`. It is configurable to suggest using either
+      # `RuntimeError` (default) or `StandardError` instead.
       #
+      # @example EnforcedStyle: runtime_error (default)
       #   # bad
       #
       #   class C < Exception; end
       #
-      # @example
-      #
-      #   # EnforcedStyle: runtime_error (default)
-      #
       #   # good
       #
       #   class C < RuntimeError; end
       #
-      # @example
+      # @example EnforcedStyle: standard_error
+      #   # bad
       #
-      #   # EnforcedStyle: standard_error
+      #   class C < Exception; end
       #
       #   # good
       #
@@ -32,26 +28,31 @@ module RuboCop
       class InheritException < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Inherit from `%s` instead of `Exception`.'.freeze
+        MSG = 'Inherit from `%s` instead of `%s`.'.freeze
         PREFERRED_BASE_CLASS = {
           runtime_error: 'RuntimeError',
           standard_error: 'StandardError'
         }.freeze
+        ILLEGAL_CLASSES = %w[
+          Exception
+          SystemStackError
+          NoMemoryError
+          SecurityError
+          NotImplementedError
+          LoadError
+          SyntaxError
+          ScriptError
+          Interrupt
+          SignalException
+          SystemExit
+        ].freeze
 
         def on_class(node)
           _class, base_class, _body = *node
 
-          return if base_class.nil?
-
-          check(base_class)
-        end
-
-        private
+          return unless base_class && illegal_class_name?(base_class)
 
-        def check(node)
-          if node.const_name == 'Exception'
-            add_offense(node, :expression, format(MSG, preferred_base_class))
-          end
+          add_offense(base_class)
         end
 
         def autocorrect(node)
@@ -60,6 +61,16 @@ module RuboCop
           end
         end
 
+        private
+
+        def message(node)
+          format(MSG, preferred_base_class, node.const_name)
+        end
+
+        def illegal_class_name?(class_node)
+          ILLEGAL_CLASSES.include?(class_node.const_name)
+        end
+
         def preferred_base_class
           PREFERRED_BASE_CLASS[style]
         end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for interpolation in a single quoted string.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   foo = 'something with #{interpolation} inside'
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   foo = "something with #{interpolation} inside"
+      class InterpolationCheck < Cop
+        MSG = 'Interpolation in single quoted string detected. '\
+	      'Use double quoted strings if you need interpolation.'.freeze
+
+        def on_str(node)
+          return if heredoc?(node)
+          return if node.parent && node.parent.dstr_type?
+          return unless node.str_content.scrub =~ /#\{.*\}/
+          add_offense(node)
+        end
+
+        def heredoc?(node)
+          node.loc.is_a?(Parser::Source::Map::Heredoc) ||
+            (node.parent && heredoc?(node.parent))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/{literal_in_condition.rb → literal_as_condition.rb}

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,16 +9,29 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   if 20
       #     do_something
       #   end
       #
+      # @example
+      #
+      #   # bad
+      #
       #   if some_var && true
       #     do_something
       #   end
       #
-      class LiteralInCondition < Cop
-        MSG = 'Literal `%s` appeared in a condition.'.freeze
+      # @example
+      #
+      #   # good
+      #
+      #   if some_var && some_condition
+      #     do_something
+      #   end
+      class LiteralAsCondition < Cop
+        MSG = 'Literal `%s` appeared as a condition.'.freeze
 
         def on_if(node)
           check_for_literal(node)
@@ -41,18 +53,23 @@ module RuboCop
           check_for_literal(node)
         end
 
-        def on_case(node)
-          cond, *whens, _else = *node
-
-          if cond
-            check_case_cond(cond)
+        def on_case(case_node)
+          if case_node.condition
+            check_case(case_node)
           else
-            whens.each do |when_node|
-              check_for_literal(when_node)
+            case_node.each_when do |when_node|
+              next unless when_node.conditions.all?(&:literal?)
+
+              add_offense(when_node)
             end
           end
         end
 
+        def on_send(node)
+          return unless node.negation_method?
+          check_for_literal(node)
+        end
+
         def message(node)
           format(MSG, node.source)
         end
@@ -60,28 +77,16 @@ module RuboCop
         private
 
         def check_for_literal(node)
-          cond, = *node
-
-          # if the cond node is literal we obviously have a problem
+          cond = condition(node)
           if cond.literal?
-            add_offense(cond, :expression)
+            add_offense(cond)
           else
-            # alternatively we have to consider a logical node with a
-            # literal argument
             check_node(cond)
           end
         end
 
-        def not?(node)
-          return false unless node && node.type == :send
-
-          _receiver, method_name, *_args = *node
-
-          method_name == :!
-        end
-
         def basic_literal?(node)
-          if node && node.type == :array
+          if node.array_type?
             primitive_array?(node)
           else
             node.basic_literal?
@@ -95,34 +100,40 @@ module RuboCop
         def check_node(node)
           return unless node
 
-          if not?(node)
+          if node.keyword_bang?
             receiver, = *node
 
             handle_node(receiver)
-          elsif [:and, :or].include?(node.type)
-            *operands = *node
-            operands.each do |op|
-              handle_node(op)
-            end
-          elsif node.type == :begin && node.children.size == 1
-            child_node = node.children.first
-            handle_node(child_node)
+          elsif LOGICAL_OPERATOR_NODES.include?(node.type)
+            node.each_child_node { |op| handle_node(op) }
+          elsif node.begin_type? && node.children.one?
+            handle_node(node.children.first)
           end
         end
 
         def handle_node(node)
           if node.literal?
-            add_offense(node, :expression)
-          elsif [:send, :and, :or, :begin].include?(node.type)
+            add_offense(node)
+          elsif %i[send and or begin].include?(node.type)
             check_node(node)
           end
         end
 
-        def check_case_cond(node)
-          return if node.type == :array && !primitive_array?(node)
-          return if node.type == :dstr
+        def check_case(case_node)
+          condition = case_node.condition
+
+          return if condition.array_type? && !primitive_array?(condition)
+          return if condition.dstr_type?
+
+          handle_node(condition)
+        end
 
-          handle_node(node)
+        def condition(node)
+          if node.send_type?
+            node.receiver
+          else
+            node.condition
+          end
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,19 +7,27 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   "result is #{10}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is 10"
       class LiteralInInterpolation < Cop
         MSG = 'Literal interpolation detected.'.freeze
-        COMPOSITE = [:array, :hash, :pair, :irange, :erange].freeze
+        COMPOSITE = %i[array hash pair irange erange].freeze
 
         def on_dstr(node)
-          node.children.select { |n| n.type == :begin }.each do |begin_node|
+          node.each_child_node(:begin) do |begin_node|
             final_node = begin_node.children.last
             next unless final_node
             next if special_keyword?(final_node)
             next unless prints_as_self?(final_node)
 
-            add_offense(final_node, :expression)
+            add_offense(final_node)
           end
         end
 
@@ -35,7 +42,7 @@ module RuboCop
 
         def special_keyword?(node)
           # handle strings like __FILE__
-          (node.type == :str && !node.loc.respond_to?(:begin)) ||
+          (node.str_type? && !node.loc.respond_to?(:begin)) ||
             node.source_range.is?('__LINE__')
         end
 
@@ -54,9 +61,7 @@ module RuboCop
           end_pos =
             node.loc.end ? node.loc.end.begin_pos : node.loc.expression.end_pos
 
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.loc.begin.end_pos,
-                                    end_pos).source
+          range_between(node.loc.begin.end_pos, end_pos).source
         end
 
         # Does node print its own source when converted to a string?

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

@@ -1,10 +1,45 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks for uses of *begin...end while/until something*.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # using while
+      #   begin
+      #     do_something
+      #   end while some_condition
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # using until
+      #   begin
+      #     do_something
+      #   end until some_condition
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # using while
+      #   while some_condition
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # using until
+      #   until some_condition
+      #     do_something
+      #   end
       class Loop < Cop
         MSG = 'Use `Kernel#loop` with `break` rather than ' \
               '`begin/end/until`(or `while`).'.freeze
@@ -20,7 +55,7 @@ module RuboCop
         private
 
         def register_offense(node)
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
       end
     end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/UnneededDisable
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there is an `# rubocop:enable ...` statement
+      # after a `# rubocop:disable ...` statement. This will prevent leaving
+      # cop disables on wide ranges of code, that latter contributors to
+      # a file wouldn't be aware of.
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: .inf
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #   # y = 1
+      #   # EOF
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # EOF
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: 2
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # With the previous, there are 2 lines on which cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   x += 1
+      #   # Including this, that's 3 lines on which the cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      class MissingCopEnableDirective < Cop
+        MSG = 'Re-enable %{cop} cop with `# rubocop:enable` after disabling it.'
+              .freeze
+        MSG_BOUND = 'Re-enable %{cop} cop within %{max_range} lines after ' \
+                    'disabling it.'.freeze
+
+        def investigate(processed_source)
+          max_range = cop_config['MaximumRangeSize']
+          processed_source.disabled_line_ranges.each do |cop, line_ranges|
+            line_ranges.each do |line_range|
+              # This has to remain a strict inequality to handle
+              # the case when max_range is Float::INFINITY
+              next if line_range.max - line_range.min < max_range + 2
+              range = source_range(processed_source.buffer,
+                                   line_range.min,
+                                   (0..0))
+              add_offense(range,
+                          location: range,
+                          message: message(max_range: max_range, cop: cop))
+            end
+          end
+        end
+
+        private
+
+        def message(max_range:, cop:)
+          if max_range == Float::INFINITY
+            format(MSG, cop: cop)
+          else
+            format(MSG_BOUND, cop: cop, max_range: max_range)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededDisable, Layout/SpaceAroundOperators

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # In math and Python, we can use `x < y < z` style comparison to compare
+      # multiple value. However, we can't use the comparison in Ruby. However,
+      # the comparison is not syntax error. This cop checks the bad usage of
+      # comparison operators.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   x < y < z
+      #   10 <= x <= 20
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   x < y && y < z
+      #   10 <= x && x <= 20
+      class MultipleCompare < Cop
+        MSG = 'Use the `&&` operator to compare multiple values.'.freeze
+
+        def_node_matcher :multiple_compare?, <<-PATTERN
+          (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
+        PATTERN
+
+        def on_send(node)
+          return unless multiple_compare?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          center = multiple_compare?(node)
+          new_center = "#{center.source} && #{center.source}"
+
+          lambda do |corrector|
+            corrector.replace(center.source_range, new_center)
+          end
+        end
+      end
+    end
+  end
+end