rubocop 0.46.0 → 0.47.0

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

@@ -8,10 +8,15 @@ module RuboCop
       # that big. If you need a float that big, something is wrong with you.
       #
       # @example
+      #
       #   # bad
+      #
       #   float = 3.0e400
       #
+      # @example
+      #
       #   # good
+      #
       #   float = 42.9
       class FloatOutOfRange < Cop
         MSG = 'Float out of range.'.freeze

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

@@ -9,8 +9,15 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   format('A value: %s and another: %i', a_value)
       #
+      # @example
+      #
+      #   # good
+      #
+      #   format('A value: %s and another: %i', a_value, another)
       class FormatParameterMismatch < Cop
         # http://rubular.com/r/CvpbxkcTzy
         MSG = "Number of arguments (%i) to `%s` doesn't match the number of " \
@@ -38,8 +45,16 @@ module RuboCop
 
           num_of_format_args, num_of_expected_fields = count_matches(node)
 
-          num_of_format_args != :unknown &&
-            num_of_expected_fields != num_of_format_args
+          return false if num_of_format_args == :unknown
+          matched_arguments_count?(num_of_expected_fields, num_of_format_args)
+        end
+
+        def matched_arguments_count?(expected, passed)
+          if passed < 0
+            expected < passed.abs
+          else
+            expected != passed
+          end
         end
 
         def called_on_string?(node)
@@ -85,11 +100,11 @@ module RuboCop
           receiver_node, _method_name, *args = *node
 
           if (sprintf?(node) || format?(node)) && !heredoc?(node)
-            number_of_args_for_format = (args.size - 1)
+            number_of_args_for_format = arguments_count(args) - 1
             number_of_expected_fields = expected_fields_count(args.first)
           elsif percent?(node) && args.first.array_type?
             number_of_expected_fields = expected_fields_count(receiver_node)
-            number_of_args_for_format = args.first.child_nodes.size
+            number_of_args_for_format = arguments_count(args.first.child_nodes)
           else
             number_of_args_for_format = number_of_expected_fields = :unknown
           end
@@ -120,6 +135,16 @@ module RuboCop
             .reduce(0) { |acc, elem| acc + (elem[2] =~ /\*/ ? 2 : 1) }
         end
 
+        def arguments_count(args)
+          if args.empty?
+            0
+          elsif args.last.type == :splat
+            -(args.count - 1)
+          else
+            args.count
+          end
+        end
+
         def format?(node)
           format_method?(:format, node)
         end

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

@@ -4,6 +4,46 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for *rescue* blocks with no body.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
       class HandleExceptions < Cop
         MSG = 'Do not suppress exceptions.'.freeze
 

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

@@ -7,10 +7,15 @@ module RuboCop
       # which are on the same line.
       #
       # @example
-      #   @bad
+      #
+      #   # bad
+      #
       #   array = ['Item 1' 'Item 2']
       #
-      #   @good
+      # @example
+      #
+      #   # good
+      #
       #   array = ['Item 1Item 2']
       #   array = ['Item 1' + 'Item 2']
       #   array = [

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

@@ -9,7 +9,9 @@ module RuboCop
       # used for that.
       #
       # @example
-      #   @bad
+      #
+      #   # bad
+      #
       #   class C
       #     private
       #
@@ -18,7 +20,10 @@ module RuboCop
       #     end
       #   end
       #
-      #   @good
+      # @example
+      #
+      #   # good
+      #
       #   class C
       #     def self.method
       #       puts 'hi'
@@ -27,6 +32,10 @@ module RuboCop
       #     private_class_method :method
       #   end
       #
+      # @example
+      #
+      #   # good
+      #
       #   class C
       #     class << self
       #       private

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

@@ -16,6 +16,9 @@ module RuboCop
       #        ^
       #
       # @example
+      #
+      #   # bad
+      #
       #   p(? )
       class InvalidCharacterLiteral < Cop
         include ParserDiagnostic

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

@@ -9,14 +9,27 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   if 20
       #     do_something
       #   end
       #
+      # @example
+      #
+      #   # bad
+      #
       #   if some_var && true
       #     do_something
       #   end
       #
+      # @example
+      #
+      #   # good
+      #
+      #   if some_var && some_condition
+      #     do_something
+      #   end
       class LiteralInCondition < Cop
         MSG = 'Literal `%s` appeared in a condition.'.freeze
 
@@ -40,14 +53,14 @@ 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, :expression)
             end
           end
         end
@@ -59,28 +72,15 @@ module RuboCop
         private
 
         def check_for_literal(node)
-          cond, = *node
-
-          # if the cond node is literal we obviously have a problem
-          if cond.literal?
-            add_offense(cond, :expression)
+          if node.condition.literal?
+            add_offense(node.condition, :expression)
           else
-            # alternatively we have to consider a logical node with a
-            # literal argument
-            check_node(cond)
+            check_node(node.condition)
           end
         end
 
-        def not?(node)
-          return false unless node && node.send_type?
-
-          _receiver, method_name, *_args = *node
-
-          method_name == :!
-        end
-
         def basic_literal?(node)
-          if node && node.array_type?
+          if node.array_type?
             primitive_array?(node)
           else
             node.basic_literal?
@@ -94,18 +94,14 @@ 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 LOGICAL_OPERATOR_NODES.include?(node.type)
+            node.each_child_node { |op| handle_node(op) }
           elsif node.begin_type? && node.children.one?
-            child_node = node.children.first
-            handle_node(child_node)
+            handle_node(node.children.first)
           end
         end
 
@@ -117,11 +113,13 @@ module RuboCop
           end
         end
 
-        def check_case_cond(node)
-          return if node.array_type? && !primitive_array?(node)
-          return if node.dstr_type?
+        def check_case(case_node)
+          condition = case_node.condition
+
+          return if condition.array_type? && !primitive_array?(condition)
+          return if condition.dstr_type?
 
-          handle_node(node)
+          handle_node(condition)
         end
       end
     end

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

@@ -7,7 +7,15 @@ 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

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

@@ -4,6 +4,42 @@ 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

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

@@ -0,0 +1,46 @@
+# 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 `&&` operator to compare multiple value.'.freeze
+
+        def_node_matcher :multiple_compare?, <<-PATTERN
+          (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
+        PATTERN
+
+        def on_send(node)
+          return unless multiple_compare?(node)
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            center = multiple_compare?(node)
+            new_center = "#{center.source} && #{center.source}"
+            corrector.replace(center.source_range, new_center)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop checks for nested method definitions.
       #
       # @example
+      #
+      #   # bad
+      #
       #   # `bar` definition actually produces methods in the same scope
       #   # as the outer `foo` method. Furthermore, the `bar` method
       #   # will be redefined every time `foo` is invoked.
@@ -14,6 +17,25 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     bar = -> { puts 'hello' }
+      #     bar.call
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     self.class_eval do
+      #       def bar
+      #       end
+      #     end
+      #   end
       class NestedMethodDefinition < Cop
         include OnMethodDef
         extend RuboCop::NodePattern::Macros